SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Logic programming</title>

</head>

Logic programming

</h1>

</header>

Logic programming is a <a href="Programming_paradigm" title="Programming paradigm">programming</a>, <a href="Database" title="Database">database</a> and <a href="Knowledge_representation" class="mw-redirect" title="Knowledge representation">knowledge representation</a> paradigm based on formal <a href="Logic" title="Logic">logic</a>. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include <a href="Prolog" title="Prolog">Prolog</a>, <a href="Answer_set_programming" title="Answer set programming">Answer Set Programming</a> (ASP) and <a href="Datalog" title="Datalog">Datalog</a>. In all of these languages, rules are written in the form of <a href="Clause_(logic)" title="Clause (logic)">clauses</a>:

and are read as declarative sentences in logical form:

<code>A</code> is called the head of the rule, <code>B1</code>, ..., <code>Bn</code> is called the body, and the <code>Bi</code> are called <a href="Literal_(mathematical_logic)" title="Literal (mathematical logic)">literals</a> or conditions. When n = 0, the rule is called a fact and is written in the simplified form:

Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:

In the simplest case of <a href="Horn_clause" title="Horn clause">Horn clauses</a> (or "definite" clauses), all of the A, B1, ..., Bn are <a href="Atomic_formula" title="Atomic formula">atomic formulae</a> of the form p(t1 ,..., tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter.

Consider, for example, the following Horn clause program:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>mother_child(elizabeth, charles).

father_child(charles, william).

father_child(charles, harry).

parent_child(X, Y) :-

mother_child(X, Y).

parent_child(X, Y) :-

father_child(X, Y).

grandparent_child(X, Y) :-

parent_child(X, Z),

parent_child(Z, Y).

</pre></div>

Given a query, the program produces answers.

For instance for a query <code>?- parent_child(X, william)</code>, the single answer is

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>X = charles

</pre></div>

Various queries can be asked. For instance

the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:

X = elizabeth

?- grandparent_child(elizabeth, Y).

Y = william;

Y = harry.

?- grandparent_child(X, Y).

X = elizabeth

Y = william;

X = elizabeth

Y = harry.

?- grandparent_child(william, harry).

no

yes

</pre></div>

Although Horn clause logic programs are <a href="Turing_completeness" title="Turing completeness">Turing complete</a>,<a href="#cite_note-1">[1]</a><a href="#cite_note-2">[2]</a> for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the <a href="Predicate_(mathematical_logic)" class="mw-redirect" title="Predicate (mathematical logic)">predicate</a> = is defined by the clause <code> X = X </code>:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>sibling(X, Y) :-

parent_child(Z, X),

parent_child(Z, Y),

not(X = Y).

</pre></div>

Logic programming languages that include negative conditions have the knowledge representation capabilities of a <a href="Non-monotonic_logic" title="Non-monotonic logic">non-monotonic logic</a>.

In ASP and Datalog, logic programs have only a <a href="Declarative_programming" title="Declarative programming">declarative</a> reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a <a href="Procedural_programming" title="Procedural programming">procedural</a> interpretation as goal-reduction procedures. From this point of view, clause A :- B1,...,Bn is understood as:

<dl><dd>to solve <code>A</code>, solve <code>B1</code>, and ... and solve <code>Bn</code>.</dd></dl>

Negative conditions in the bodies of clauses also have a procedural interpretation, known as <a href="Negation_as_failure" title="Negation as failure">negation as failure</a>: A negative literal <code> not B</code> is deemed to hold if and only if the positive literal <code> B</code> fails to hold.

Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of <a href="Formal_methods" title="Formal methods">formal methods</a> for logic-based <a href="Formal_verification" title="Formal verification">program verification</a> and <a href="Program_transformation" title="Program transformation">program transformation</a>.

<div class="mw-heading mw-heading2"><h2 id="History">History</h2></div>

The use of mathematical logic to represent and execute <a href="Computer_program" title="Computer program">computer programs</a> is also a feature of the <a href="Lambda_calculus" title="Lambda calculus">lambda calculus</a>, developed by <a href="Alonzo_Church" title="Alonzo Church">Alonzo Church</a> in the 1930s. However, the first proposal to use the <a href="Clausal_normal_form" class="mw-redirect" title="Clausal normal form">clausal</a> form of logic for representing computer programs was made by <a href="Cordell_Green" title="Cordell Green">Cordell Green</a>.<a href="#cite_note-3">[3]</a> This used an axiomatization of a subset of <a href="LISP" class="mw-redirect" title="LISP">LISP</a>, together with a representation of an input-output relation, to compute the relation by simulating the execution of the program in LISP. Foster and Elcock's <a href="Absys" title="Absys">Absys</a>, on the other hand, employed a combination of equations and lambda calculus in an assertional programming language that places no constraints on the order in which operations are performed.<a href="#cite_note-4">[4]</a>

Logic programming, with its current syntax of facts and rules, can be traced back to debates in the late 1960s and early 1970s about declarative versus procedural representations of knowledge in <a href="Artificial_intelligence" title="Artificial intelligence">artificial intelligence</a>. Advocates of declarative representations were notably working at <a href="Stanford_University" title="Stanford University">Stanford</a>, associated with <a href="John_McCarthy_(computer_scientist)" title="John McCarthy (computer scientist)">John McCarthy</a>, <a href="Bertram_Raphael" title="Bertram Raphael">Bertram Raphael</a> and Cordell Green, and in <a href="University_of_Edinburgh" title="University of Edinburgh">Edinburgh</a>, with <a href="John_Alan_Robinson" title="John Alan Robinson">John Alan Robinson</a> (an academic visitor from <a href="Syracuse_University" title="Syracuse University">Syracuse University</a>), <a href="Patrick_J._Hayes" class="mw-redirect" title="Patrick J. Hayes">Pat Hayes</a>, and <a href="Robert_Kowalski" title="Robert Kowalski">Robert Kowalski</a>. Advocates of procedural representations were mainly centered at <a href="MIT" class="mw-redirect" title="MIT">MIT</a>, under the leadership of <a href="Marvin_Minsky" title="Marvin Minsky">Marvin Minsky</a> and <a href="Seymour_Papert" title="Seymour Papert">Seymour Papert</a>.<a href="#cite_note-5">[5]</a>

Although it was based on the proof methods of logic, <a href="Planner_(programming_language)" title="Planner (programming language)">Planner</a>, developed by <a href="Carl_Hewitt" title="Carl Hewitt">Carl Hewitt</a> at MIT, was the first language to emerge within this proceduralist paradigm.<a href="#cite_note-6">[6]</a> Planner featured pattern-directed invocation of procedural plans from goals (i.e. goal-reduction or <a href="Backward_chaining" title="Backward chaining">backward chaining</a>) and from assertions (i.e. <a href="Forward_chaining" title="Forward chaining">forward chaining</a>). The most influential implementation of Planner was the subset of Planner, called Micro-Planner, implemented by <a href="Gerald_Jay_Sussman" title="Gerald Jay Sussman">Gerry Sussman</a>, <a href="Eugene_Charniak" title="Eugene Charniak">Eugene Charniak</a> and <a href="Terry_Winograd" title="Terry Winograd">Terry Winograd</a>. Winograd used Micro-Planner to implement the landmark, natural-language understanding program <a href="SHRDLU" title="SHRDLU">SHRDLU</a>.<a href="#cite_note-Winograd-7">[7]</a> For the sake of efficiency, Planner used a backtracking control structure so that only one possible computation path had to be stored at a time. Planner gave rise to the programming languages <a href="Richard_Waldinger#QA4" title="Richard Waldinger">QA4</a>,<a href="#cite_note-Rulifson-8">[8]</a> Popler,<a href="#cite_note-9">[9]</a> Conniver,<a href="#cite_note-10">[10]</a> QLISP,<a href="#cite_note-11">[11]</a> and the concurrent language Ether.<a href="#cite_note-12">[12]</a>

Hayes and Kowalski in Edinburgh tried to reconcile the logic-based declarative approach to knowledge representation with Planner's procedural approach. Hayes (1973) developed an equational language, Golux, in which different procedures could be obtained by altering the behavior of the theorem prover.<a href="#cite_note-13">[13]</a>

In the meanwhile, <a href="Alain_Colmerauer" title="Alain Colmerauer">Alain Colmerauer</a> in <a href="Marseille" title="Marseille">Marseille</a> was working on <a href="Natural-language_understanding" class="mw-redirect" title="Natural-language understanding">natural-language understanding</a>, using logic to represent semantics and using resolution for question-answering. During the summer of 1971, Colmerauer invited Kowalski to Marseille, and together they discovered that the clausal form of logic could be used to represent <a href="Formal_grammars" class="mw-redirect" title="Formal grammars">formal grammars</a> and that resolution theorem provers could be used for parsing. They observed that some theorem provers, like hyper-resolution,<a href="#cite_note-14">[14]</a> behave as bottom-up parsers and others, like <a href="SLD_resolution" title="SLD resolution">SL resolution</a> (1971)<a href="#cite_note-15">[15]</a> behave as top-down parsers.

It was in the following summer of 1972, that Kowalski, again working with Colmerauer, developed the procedural interpretation of implications in clausal form. It also became clear that such clauses could be restricted to definite clauses or <a href="Horn_clause" title="Horn clause">Horn clauses</a>, and that SL-resolution could be restricted (and generalised) to <a href="SLD_resolution" title="SLD resolution">SLD resolution</a>. Kowalski's procedural interpretation and SLD were described in a 1973 memo, published in 1974.<a href="#cite_note-Kowalski-16">[16]</a>

Colmerauer, with Philippe Roussel, used the procedural interpretation as the basis of Prolog, which was implemented in the summer and autumn of 1972. The first Prolog program, also written in 1972 and implemented in Marseille, was a French question-answering system. The use of Prolog as a practical programming language was given great momentum by the development of a compiler by <a href="David_H._D._Warren" title="David H. D. Warren">David H. D. Warren</a> in Edinburgh in 1977. Experiments demonstrated that Edinburgh Prolog could compete with the processing speed of other <a href="Symbolic_programming" title="Symbolic programming">symbolic programming</a> languages such as <a href="Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a>.<a href="#cite_note-17">[17]</a> Edinburgh Prolog became the de facto standard and strongly influenced the definition of <a href="International_Organization_for_Standardization" title="International Organization for Standardization">ISO</a> standard Prolog.

Logic programming gained international attention during the 1980s, when it was chosen by the Japanese <a href="Ministry_of_International_Trade_and_Industry" title="Ministry of International Trade and Industry">Ministry of International Trade and Industry</a> to develop the software for the <a href="Fifth_Generation_Computer_Systems" title="Fifth Generation Computer Systems">Fifth Generation Computer Systems</a> (FGCS) project. The FGCS project aimed to use logic programming to develop advanced <a href="Artificial_Intelligence" class="mw-redirect" title="Artificial Intelligence">Artificial Intelligence</a> applications on massively <a href="Parallel_computing" title="Parallel computing">parallel computers</a>. Although the project initially explored the use of Prolog, it later adopted the use of <a href="Concurrent_logic_programming" title="Concurrent logic programming">concurrent logic programming</a>, because it was closer to the FGCS computer architecture.

However, the committed choice feature of concurrent logic programming interfered with the language's logical semantics<a href="#cite_note-18">[18]</a> and with its suitability for knowledge representation and problem solving applications. Moreover, the parallel computer systems developed in the project failed to compete with advances taking place in the development of more conventional, general-purpose computers. Together these two issues resulted in the FGCS project failing to meet its objectives. Interest in both logic programming and AI fell into world-wide decline.<a href="#cite_note-19">[19]</a>

In the meanwhile, more declarative logic programming approaches, including those based on the use of Prolog, continued to make progress independently of the FGCS project. In particular, although Prolog was developed to combine declarative and procedural representations of knowledge, the purely declarative interpretation of logic programs became the focus for applications in the field of <a href="Deductive_database" title="Deductive database">deductive databases</a>. Work in this field became prominent around 1977, when Hervé Gallaire and <a href="Jack_Minker" title="Jack Minker">Jack Minker</a> organized a workshop on logic and databases in Toulouse.<a href="#cite_note-20">[20]</a> The field was eventually renamed as <a href="Datalog" title="Datalog">Datalog</a>.

This focus on the logical, declarative reading of logic programs was given further impetus by the development of <a href="Constraint_logic_programming" title="Constraint logic programming">constraint logic programming</a> in the 1980s and <a href="Answer_set_programming" title="Answer set programming">Answer Set Programming</a> in the 1990s. It is also receiving renewed emphasis in recent applications of Prolog<a href="#cite_note-Prolog_Book-21">[21]</a>

The <a href="Association_for_Logic_Programming" title="Association for Logic Programming">Association for Logic Programming</a> (ALP) was founded in 1986 to promote Logic Programming. Its official journal until 2000, was <a href="The_Journal_of_Logic_Programming" class="mw-redirect" title="The Journal of Logic Programming">The Journal of Logic Programming</a>. Its founding <a href="Editor-in-chief" title="Editor-in-chief">editor-in-chief</a> was <a href="J._Alan_Robinson" class="mw-redirect" title="J. Alan Robinson">J. Alan Robinson</a>.<a href="#cite_note-22">[22]</a> In 2001, the journal was renamed The Journal of Logic and Algebraic Programming, and the official journal of ALP became <a href="Theory_and_Practice_of_Logic_Programming" class="mw-redirect" title="Theory and Practice of Logic Programming">Theory and Practice of Logic Programming</a>, published by <a href="Cambridge_University_Press" title="Cambridge University Press">Cambridge University Press</a>.

<div class="mw-heading mw-heading2"><h2 id="Concepts">Concepts</h2></div>

Logic programs enjoy a rich variety of semantics and problem solving methods, as well as a wide range of applications in programming, databases, knowledge representation and problem solving.

<div class="mw-heading mw-heading3"><h3 id="Algorithm_=_Logic_+_Control">Algorithm = Logic + Control</h3></div>

The procedural interpretation of logic programs, which uses backward reasoning to reduce goals to subgoals, is a special case of the use of a problem-solving strategy to control the use of a declarative, logical representation of knowledge to obtain the behaviour of an algorithm. More generally, different problem-solving strategies can be applied to the same logical representation to obtain different algorithms. Alternatively, different algorithms can be obtained with a given problem-solving strategy by using different logical representations.<a href="#cite_note-23">[23]</a>

The two main problem-solving strategies are <a href="Backward_chaining" title="Backward chaining">backward reasoning</a> (goal reduction) and <a href="Forward_chaining" title="Forward chaining">forward reasoning</a>, also known as top-down and bottom-up reasoning, respectively.

In the simple case of a propositional Horn clause program and a top-level atomic goal, backward reasoning determines an <a href="And-or_tree" class="mw-redirect" title="And-or tree">and-or tree</a>, which constitutes the search space for solving the goal. The top-level goal is the root of the tree. Given any node in the tree and any clause whose head matches the node, there exists a set of child nodes corresponding to the sub-goals in the body of the clause. These child nodes are grouped together by an "and". The alternative sets of children corresponding to alternative ways of solving the node are grouped together by an "or".

Any search strategy can be used to search this space. Prolog uses a sequential, last-in-first-out, backtracking strategy, in which only one alternative and one sub-goal are considered at a time. For example, subgoals can be solved in parallel, and clauses can also be tried in parallel. The first strategy is called <style data-mw-deduplicate="TemplateStyles:r1238216509">

/* start https://en.wikipedia.org/ */

.mw-parser-output .vanchor>:target~.vanchor-text{background-color:#b1d2ff}@media screen{html.skin-theme-clientpref-night .mw-parser-output .vanchor>:target~.vanchor-text{background-color:#0f4dc9}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .vanchor>:target~.vanchor-text{background-color:#0f4dc9}}

/* end https://en.wikipedia.org/ */

</style>and-parallel and the second strategy is called or-parallel. Other search strategies, such as intelligent backtracking,<a href="#cite_note-24">[24]</a> or best-first search to find an optimal solution,<a href="#cite_note-25">[25]</a> are also possible.

In the more general, non-propositional case, where sub-goals can share variables, other strategies can be used, such as choosing the subgoal that is most highly instantiated or that is sufficiently instantiated so that only one procedure applies.<a href="#cite_note-26">[26]</a> Such strategies are used, for example, in <a href="Concurrent_logic_programming" title="Concurrent logic programming">concurrent logic programming</a>.

In most cases, backward reasoning from a query or goal is more efficient than forward reasoning. But sometimes with Datalog and Answer Set Programming, there may be no query that is separate from the set of clauses as a whole, and then generating all the facts that can be derived from the clauses is a sensible problem-solving strategy. Here is another example, where forward reasoning beats backward reasoning in a more conventional computation task, where the goal <code>?- fibonacci(n, Result)</code> is to find the nth fibonacci number:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>fibonacci(0, 0).

fibonacci(1, 1).

fibonacci(N, Result) :-

N > 1,

N1 is N - 1,

N2 is N - 2,

fibonacci(N1, F1),

fibonacci(N2, F2),

Result is F1 + F2.

</pre></div>

Here the relation <code>fibonacci(N, M)</code> stands for the function <code>fibonacci(N) = M</code>, and the predicate <code>N is Expression</code> is Prolog notation for the predicate that instantiates the variable <code>N</code> to the value of <code>Expression</code>.

Given the goal of computing the fibonacci number of <code>n</code>, backward reasoning reduces the goal to the two subgoals of computing the fibonacci numbers of n-1 and n-2. It reduces the subgoal of computing the fibonacci number of n-1 to the two subgoals of computing the fibonacci numbers of n-2 and n-3, redundantly computing the fibonacci number of n-2. This process of reducing one fibonacci subgoal to two fibonacci subgoals continues until it reaches the numbers 0 and 1. Its complexity is of the order 2n. In contrast, forward reasoning generates the sequence of fibonacci numbers, starting from 0 and 1 without any recomputation, and its complexity is linear with respect to n.

Prolog cannot perform forward reasoning directly. But it can achieve the effect of forward reasoning within the context of backward reasoning by means of <a href="Tabling" class="mw-redirect" title="Tabling">tabling</a>: Subgoals are maintained in a table, along with their solutions. If a subgoal is re-encountered, it is solved directly by using the solutions already in the table, instead of re-solving the subgoals redundantly.<a href="#cite_note-27">[27]</a>

<div class="mw-heading mw-heading3"><h3 id="Relationship_with_functional_programming">Relationship with functional programming</h3></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">See also: <a href="Functional_programming#Comparison_to_logic_programming" title="Functional programming">Functional programming § Comparison to logic programming</a></div>

Logic programming can be viewed as a generalisation of functional programming, in which functions are a special case of relations.<a href="#cite_note-dis-28">[28]</a>

For example, the function, mother(X) = Y, (every X has only one mother Y) can be represented by the relation mother(X, Y). In this respect, logic programs are similar to <a href="Relational_databases" class="mw-redirect" title="Relational databases">relational databases</a>, which also represent functions as relations.

Compared with relational syntax, functional syntax is more compact for nested functions. For example, in functional syntax the definition of maternal grandmother can be written in the nested form:

</pre></div>

The same definition in relational notation needs to be written in the unnested, flattened form:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>maternal_grandmother(X, Y) :- mother(X, Z), mother(Z, Y).

</pre></div>

However, nested syntax can be regarded as syntactic sugar for unnested syntax. <a href="Ciao_(programming_language)" title="Ciao (programming language)">Ciao</a> Prolog, for example, transforms functional syntax into relational form and executes the resulting logic program using the standard Prolog execution strategy.<a href="#cite_note-29">[29]</a> Moreover, the same transformation can be used to execute nested relations that are not functional. For example:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>grandparent(X) := parent(parent(X)).

parent(X) := mother(X).

parent(X) := father(X).

mother(charles) := elizabeth.

father(charles) := phillip.

mother(harry) := diana.

father(harry) := charles.

?- grandparent(X,Y).

X = harry,

Y = elizabeth.

X = harry,

Y = phillip.

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Relationship_with_relational_programming">Relationship with relational programming</h3></div>

The term relational programming has been used to cover a variety of programming languages that treat functions as a special case of relations. Some of these languages, such as <a href="MiniKanren" title="MiniKanren">miniKanren</a><a href="#cite_note-dis-28">[28]</a>

and relational linear programming<a href="#cite_note-30">[30]</a>

are logic programming languages in the sense of this article.

However, the relational language RML is an imperative programming language

<a href="#cite_note-31">[31]</a> whose core construct is a

relational expression, which is similar to an expression in first-order predicate logic.

Other relational programming languages are based on the relational calculus<a href="#cite_note-32">[32]</a> or relational algebra.<a href="#cite_note-33">[33]</a>

<div class="mw-heading mw-heading3"><h3 id="Semantics_of_Horn_clause_programs">Semantics of Horn clause programs</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Syntax_and_semantics_of_logic_programming" title="Syntax and semantics of logic programming">Syntax and semantics of logic programming</a></div>

Viewed in purely logical terms, there are two approaches to the declarative semantics of Horn clause logic programs: One approach is the original <a href="Logical_consequence" title="Logical consequence">logical consequence</a> semantics, which understands solving a goal as showing that the goal is a theorem that is true in all <a href="Structure_(mathematical_logic)#Structures_and_first-order_logic" title="Structure (mathematical logic)">models</a> of the program.

In this approach, computation is <a href="Automated_theorem_proving" title="Automated theorem proving">theorem-proving</a> in <a href="First-order_logic" title="First-order logic">first-order logic</a>; and both <a href="Backward_chaining" title="Backward chaining">backward reasoning</a>, as in SLD resolution, and <a href="Forward_chaining" title="Forward chaining">forward reasoning</a>, as in hyper-resolution, are correct and complete theorem-proving methods. Sometimes such theorem-proving methods are also regarded as providing a separate <a href="Proof-theoretic_semantics" title="Proof-theoretic semantics">proof-theoretic (or operational) semantics</a> for logic programs. But from a logical point of view, they are proof methods, rather than semantics.

The other approach to the declarative semantics of Horn clause programs is the <a href="Satisfiability" title="Satisfiability">satisfiability</a> semantics, which understands solving a goal as showing that the goal is true (or satisfied) in some <a href="Intended_interpretation" class="mw-redirect" title="Intended interpretation">intended (or standard) model</a> of the program. For Horn clause programs, there always exists such a standard model: It is the unique minimal model of the program.

Informally speaking, a minimal model is a model that, when it is viewed as the set of all (variable-free) facts that are true in the model, contains no smaller set of facts that is also a model of the program.

For example, the following facts represent the minimal model of the family relationships example in the introduction of this article. All other variable-free facts are false in the model:

father_child(charles, william).

father_child(charles, harry).

parent_child(elizabeth, charles).

parent_child(charles, william).

parent_child(charles, harry).

grandparent_child(elizabeth, william).

grandparent_child(elizabeth, harry).

</pre></div>

The satisfiability semantics also has an alternative, more mathematical characterisation as the <a href="Least_fixed_point" title="Least fixed point">least fixed point</a> of the function that uses the rules in the program to derive new facts from existing facts in one step of inference.

Remarkably, the same problem-solving methods of forward and backward reasoning, which were originally developed for the logical consequence semantics, are equally applicable to the satisfiability semantics: Forward reasoning generates the minimal model of a Horn clause program, by deriving new facts from existing facts, until no new additional facts can be generated. Backward reasoning, which succeeds by reducing a goal to subgoals, until all subgoals are solved by facts, ensures that the goal is true in the minimal model, without generating the model explicitly.<a href="#cite_note-34">[34]</a>

The difference between the two declarative semantics can be seen with the definitions of addition and multiplication in <a href="Peano_arithmetic" class="mw-redirect" title="Peano arithmetic">successor arithmetic</a>, which represents the natural numbers <code>0, 1, 2, ...</code> as a sequence of terms of the form <code>0, s(0), s(s(0)), ...</code>. In general, the term <code>s(X)</code> represents the successor of <code>X,</code> namely <code>X + 1.</code> Here are the standard definitions of addition and multiplication in functional notation:

<pre> X + 0 = X.

X + s(Y) = s(X + Y).

i.e. X + (Y + 1) = (X + Y) + 1

X × 0 = 0.

X × s(Y) = X + (X × Y).

i.e. X × (Y + 1) = X + (X × Y).

</pre>

Here are the same definitions as a logic program, using <code>add(X, Y, Z)</code> to represent <code>X + Y = Z,</code> and <code>multiply(X, Y, Z)</code> to represent <code>X × Y = Z</code>:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>add(X, 0, X).

add(X, s(Y), s(Z)) :- add(X, Y, Z).

multiply(X, 0, 0).

multiply(X, s(Y), W) :- multiply(X, Y, Z), add(X, Z, W).

</pre></div>

The two declarative semantics both give the same answers for the same existentially quantified conjunctions of addition and multiplication goals. For example <code>2 × 2 = X</code> has the solution <code>X = 4</code>; and <code>X × X = X + X</code> has two solutions <code>X = 0</code> and <code>X = 2</code>:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>?- multiply(s(s(0)), s(s(0)), X).

?- multiply(X, X, Y), add(X, X, Y).

X = 0, Y = 0.

X = s(s(0)), Y = s(s(s(s(0)))).

</pre></div>

However, with the logical-consequence semantics, there are non-standard models of the program, in which, for example, <code>add(s(s(0)), s(s(0)), s(s(s(s(s(0)))))),</code> i.e. <code>2 + 2 = 5</code> is true. But with the satisfiability semantics, there is only one model, namely the standard model of arithmetic, in which <code>2 + 2 = 5</code> is false.

In both semantics, the goal <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr">?- add(s(s(0)), s(s(0)), s(s(s(s(s(0))))))</code> fails. In the satisfiability semantics, the failure of the goal means that the truth value of the goal is false. But in the logical consequence semantics, the failure means that the truth value of the goal is unknown.

<div class="mw-heading mw-heading3"><h3 id="Negation_as_failure">Negation as failure</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Negation_as_failure" title="Negation as failure">Negation as failure</a></div>

<a href="Negation_as_failure" title="Negation as failure">Negation as failure</a> (NAF), as a way of concluding that a negative condition <code>not p</code> holds by showing that the positive condition <code>p</code> fails to hold, was already a feature of early Prolog systems. The resulting extension of <a href="SLD_resolution" title="SLD resolution">SLD resolution</a> is called <a href="SLD_resolution#SLDNF" title="SLD resolution">SLDNF</a>. A similar construct, called "thnot", also existed in <a href="Micro-Planner_(programming_language)" class="mw-redirect" title="Micro-Planner (programming language)">Micro-Planner</a>.

The logical semantics of NAF was unresolved until <a href="Keith_Clark_(computer_scientist)" title="Keith Clark (computer scientist)">Keith Clark</a><a href="#cite_note-35">[35]</a> showed that, under certain natural conditions, NAF is an efficient, correct (and sometimes complete) way of reasoning with the logical consequence semantics using the <a href="Negation_as_failure#Completion_semantics" title="Negation as failure">completion</a> of a logic program in first-order logic.

Completion amounts roughly to regarding the set of all the program clauses with the same predicate in the head, say:

<dd><code>A :- Bodyk.</code></dd></dl>

as a definition of the predicate:

<dl><dd><code>A iff (Body1 or ... or Bodyk)</code></dd></dl>

where <code>iff</code> means "if and only if". The completion also includes axioms of equality, which correspond to <a href="Unification_(computer_science)" title="Unification (computer science)">unification</a>. Clark showed that proofs generated by SLDNF are structurally similar to proofs generated by a natural deduction style of reasoning with the completion of the program.

Consider, for example, the following program:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>should_receive_sanction(X, punishment) :-

is_a_thief(X),

not should_receive_sanction(X, rehabilitation).

should_receive_sanction(X, rehabilitation) :-

is_a_thief(X),

is_a_minor(X),

not is_violent(X).

is_a_thief(tom).

</pre></div>

Given the goal of determining whether tom should receive a sanction, the first rule succeeds in showing that tom should be punished:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>?- should_receive_sanction(tom, Sanction).

Sanction = punishment.

</pre></div>

This is because tom is a thief, and it cannot be shown that tom should be rehabilitated. It cannot be shown that tom should be rehabilitated, because it cannot be shown that tom is a minor.

If, however, we receive new information that tom is indeed a minor, the previous conclusion that tom should be punished is replaced by the new conclusion that tom should be rehabilitated:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>minor(tom).

?- should_receive_sanction(tom, Sanction).

Sanction = rehabilitation.

</pre></div>

This property of withdrawing a conclusion when new information is added, is called non-monotonicity, and it makes logic programming a <a href="Non-monotonic_logic" title="Non-monotonic logic">non-monotonic logic</a>.

But, if we are now told that tom is violent, the conclusion that tom should be punished will be reinstated:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>violent(tom).

Sanction = punishment.

</pre></div>

The completion of this program is:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>should_receive_sanction(X, Sanction) iff

Sanction = punishment, is_a_thief(X),

or Sanction = rehabilitation, is_a_thief(X), is_a_minor(X),

not is_violent(X).

is_a_thief(X) iff X = tom.

is_a_minor(X) iff X = tom.

is_violent(X) iff X = tom.

</pre></div>

The notion of completion is closely related to <a href="John_McCarthy_(computer_scientist)" title="John McCarthy (computer scientist)">John McCarthy's</a> <a href="Circumscription_(logic)" title="Circumscription (logic)">circumscription</a> semantics for default reasoning,<a href="#cite_note-36">[36]</a> and to <a href="Raymond_Reiter" title="Raymond Reiter">Ray Reiter's</a> <a href="Closed_world_assumption" class="mw-redirect" title="Closed world assumption">closed world assumption</a>.<a href="#cite_note-37">[37]</a>

The completion semantics for negation is a logical consequence semantics, for which SLDNF provides a proof-theoretic implementation. However, in the 1980s, the satisfiability semantics became more popular for logic programs with negation. In the satisfiability semantics, negation is interpreted according to the classical definition of truth in an intended or standard model of the logic program.

In the case of logic programs with negative conditions, there are two main variants of the satisfiability semantics: In the <a href="Well-founded_semantics" title="Well-founded semantics">well-founded semantics</a>, the intended model of a logic program is a unique, three-valued, minimal model, which always exists. The well-founded semantics generalises the notion of <a href="Inductive_definition" class="mw-redirect" title="Inductive definition">inductive definition</a> in mathematical logic.<a href="#cite_note-38">[38]</a> <a href="XSB" title="XSB">XSB Prolog</a><a href="#cite_note-39">[39]</a> implements the well-founded semantics using SLG resolution.<a href="#cite_note-40">[40]</a>

In the alternative <a href="Stable_model_semantics" title="Stable model semantics">stable model semantics</a>, there may be no intended models or several intended models, all of which are minimal and two-valued. The stable model semantics underpins <a href="Answer_set_programming" title="Answer set programming">answer set programming</a> (ASP).

Both the well-founded and stable model semantics apply to arbitrary logic programs with negation. However, both semantics coincide for <a href="Syntax_and_semantics_of_logic_programming#Stratified_negation" title="Syntax and semantics of logic programming">stratified</a> logic programs. For example, the program for sanctioning thieves is (locally) stratified, and all three semantics for the program determine the same intended model:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>should_receive_sanction(tom, punishment).

is_a_thief(tom).

is_a_minor(tom).

is_violent(tom).

</pre></div>

Attempts to understand negation in logic programming have also contributed to the development of <a href="Argumentation_framework" title="Argumentation framework">abstract argumentation frameworks</a>.<a href="#cite_note-41">[41]</a> In an argumentation interpretation of negation, the initial argument that tom should be punished because he is a thief, is attacked by the argument that he should be rehabilitated because he is a minor. But the fact that tom is violent undermines the argument that tom should be rehabilitated and reinstates the argument that tom should be punished.

<div class="mw-heading mw-heading3"><h3 id="Metalogic_programming">Metalogic programming</h3></div>

<a href="Metaprogramming" title="Metaprogramming">Metaprogramming</a>, in which programs are treated as data, was already a feature of early Prolog implementations.<a href="#cite_note-42">[42]</a><a href="#cite_note-Warren-43">[43]</a> For example, the Edinburgh DEC10 implementation of Prolog included "an interpreter and a compiler, both written in Prolog itself".<a href="#cite_note-Warren-43">[43]</a> The simplest metaprogram is the so-called "<a href="Vanilla_(computing)" class="mw-redirect" title="Vanilla (computing)">vanilla</a>" meta-interpreter:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre> solve(true).

solve((B,C)):- solve(B),solve(C).

solve(A):- clause(A,B),solve(B).

</pre></div>

where true represents an empty conjunction, and (B,C) is a composite term representing the conjunction of B and C. The predicate clause(A,B) means that there is a clause of the form A :- B.

Metaprogramming is an application of the more general use of a <a href="Metalogic" title="Metalogic">metalogic</a> or <a href="Metalanguage" title="Metalanguage">metalanguage</a> to describe and reason about another language, called the object language.

Metalogic programming allows object-level and metalevel representations to be combined, as in natural language. For example, in the following program, the atomic formula <code>attends(Person, Meeting)</code> occurs both as an object-level formula, and as an argument of the metapredicates <code>prohibited</code> and <code>approved.</code>

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>prohibited(attends(Person, Meeting)) :-

not(approved(attends(Person, Meeting))).

should_receive_sanction(Person, scolding) :- attends(Person, Meeting),

lofty(Person), prohibited(attends(Person, Meeting)).

should_receive_sanction(Person, banishment) :- attends(Person, Meeting),

lowly(Person), prohibited(attends(Person, Meeting)).

approved(attends(alice, tea_party)).

attends(mad_hatter, tea_party).

attends(dormouse, tea_party).

lofty(mad_hatter).

lowly(dormouse).

?- should_receive_sanction(X,Y).

Person = mad_hatter,

Sanction = scolding.

Person = dormouse,

Sanction = banishment.

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Relationship_with_the_Computational-representational_understanding_of_mind">Relationship with the <a href="Computational-representational_understanding_of_mind" title="Computational-representational understanding of mind">Computational-representational understanding of mind</a></h3></div>

In his popular Introduction to Cognitive Science,<a href="#cite_note-44">[44]</a> <a href="Paul_Thagard" title="Paul Thagard">Paul Thagard</a> includes logic and <a href="Rule-based_system" title="Rule-based system">rules</a> as alternative approaches to modelling human thinking. He argues that rules, which have the form IF condition THEN action, are "very similar" to logical conditionals, but they are simpler and have greater psychological plausibility (page 51). Among other differences between logic and rules, he argues that logic uses deduction, but rules use search (page 45) and can be used to reason either forward or backward (page 47). Sentences in logic "have to be interpreted as universally true", but rules can be defaults, which admit exceptions (page 44).

He states that "unlike logic, rule-based systems can also easily represent strategic information

about what to do" (page 45). For example, "IF you want to go home for the weekend, and you have bus fare, THEN

you can catch a bus". He does not observe that the same strategy of reducing a goal to subgoals can be interpreted, in the manner of logic programming, as applying backward reasoning to a logical conditional:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>can_go(you, home) :- have(you, bus_fare), catch(you, bus).

</pre></div>

All of these characteristics of rule-based systems - search, forward and backward reasoning, default reasoning, and goal-reduction - are also defining characteristics of logic programming. This suggests that Thagard's conclusion (page 56) that:

Much of human knowledge is naturally described in terms of rules, and many kinds of thinking such as planning can be modeled by rule-based systems.

</blockquote>

also applies to logic programming.

Other arguments showing how logic programming can be used to model aspects of human thinking are presented by <a href="Keith_Stenning" title="Keith Stenning">Keith Stenning</a> and <a href="Michiel_van_Lambalgen" title="Michiel van Lambalgen">Michiel van Lambalgen</a> in their book,

Human Reasoning and Cognitive Science.<a href="#cite_note-45">[45]</a> They show how the non-monotonic character of logic programs can be used to explain human performance on a variety of psychological tasks. They also show (page 237) that "closed–world reasoning in its guise as logic programming has an appealing neural implementation, unlike classical logic."

In The Proper Treatment of Events,<a href="#cite_note-46">[46]</a>

Michiel van Lambalgen and Fritz Hamm investigate the use of constraint logic programming to code "temporal notions in natural language by looking at the way human beings construct time".

<div class="mw-heading mw-heading3"><h3 id="Knowledge_representation">Knowledge representation</h3></div>

The use of logic to represent procedural knowledge and strategic information was one of the main goals contributing to the early development of logic programming. Moreover, it continues to be an important feature of the Prolog family of logic programming languages today. However, many applications of logic programming, including Prolog applications, increasingly focus on the use of logic to represent purely declarative knowledge. These applications include both the representation of general <a href="Commonsense_reasoning" title="Commonsense reasoning">commonsense</a> knowledge and the representation of domain specific <a href="Expert_system" title="Expert system">expertise</a>.

Commonsense includes knowledge about cause and effect, as formalised, for example, in the <a href="Situation_calculus" title="Situation calculus">situation calculus</a>, <a href="Event_calculus" title="Event calculus">event calculus</a> and <a href="Action_language" title="Action language">action languages</a>. Here is a simplified example, which illustrates the main features of such formalisms. The first clause states that a fact holds immediately after an event initiates (or causes) the fact. The second clause is a <a href="Frame_problem" title="Frame problem">frame axiom</a>, which states that a fact that holds at a time continues to hold at the next time unless it is terminated by an event that happens at the time. This formulation allows more than one event to occur at the same time:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>holds(Fact, Time2) :-

happens(Event, Time1),

Time2 is Time1 + 1,

initiates(Event, Fact).

holds(Fact, Time2) :-

happens(Event, Time1),

Time2 is Time1 + 1,

holds(Fact, Time1),

not(terminated(Fact, Time1)).

terminated(Fact, Time) :-

happens(Event, Time),

terminates(Event, Fact).

</pre></div>

Here <code>holds</code> is a meta-predicate, similar to <code>solve</code> above. However, whereas <code>solve</code> has only one argument, which applies to general clauses, the first argument of <code>holds</code> is a fact and the second argument is a time (or state). The atomic formula <code>holds(Fact, Time)</code> expresses that the <code>Fact</code> holds at the <code>Time</code>. Such time-varying facts are also called <a href="Fluent_(artificial_intelligence)" title="Fluent (artificial intelligence)">fluents</a>. The atomic formula <code>happens(Event, Time)</code> expresses that the Event happens at the <code>Time</code>.

The following example illustrates how these clauses can be used to reason about causality in a toy <a href="Blocks_world" title="Blocks world">blocks world</a>. Here, in the initial state at time 0, a green block is on a table and a red block is stacked on the green block (like a traffic light). At time 0, the red block is moved to the table. At time 1, the green block is moved onto the red block. Moving an object onto a place terminates the fact that the object is on any place, and initiates the fact that the object is on the place to which it is moved:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>holds(on(green_block, table), 0).

holds(on(red_block, green_block), 0).

happens(move(red_block, table), 0).

happens(move(green_block, red_block), 1).

initiates(move(Object, Place), on(Object, Place)).

terminates(move(Object, Place2), on(Object, Place1)).

?- holds(Fact, Time).

Fact = on(green_block,table),

Time = 0.

Fact = on(red_block,green_block),

Time = 0.

Time = 1.

Time = 2.

</pre></div>

Forward reasoning and backward reasoning generate the same answers to the goal <code>holds(Fact, Time)</code>. But forward reasoning generates fluents progressively in temporal order, and backward reasoning generates fluents regressively, as in the domain-specific use of <a href="Situation_calculus#Regression" title="Situation calculus">regression</a> in the <a href="Situation_calculus" title="Situation calculus">situation calculus</a>.<a href="#cite_note-47">[47]</a>

Logic programming has also proved to be useful for representing domain-specific expertise in <a href="Expert_system" title="Expert system">expert systems</a>.<a href="#cite_note-48">[48]</a> But human expertise, like general-purpose commonsense, is mostly implicit and <a href="Tacit_knowledge" title="Tacit knowledge">tacit</a>, and it is often difficult to represent such implicit knowledge in explicit rules. This difficulty does not arise, however, when logic programs are used to represent the existing, explicit rules of a business organisation or legal authority.

For example, here is a representation of a simplified version of the first sentence of the British Nationality Act, which states that a person who is born in the UK becomes a British citizen at the time of birth if a parent of the person is a British citizen at the time of birth:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>initiates(birth(Person), citizen(Person, uk)):-

time_of(birth(Person), Time),

place_of(birth(Person), uk),

parent_child(Another_Person, Person),

holds(citizen(Another_Person, uk), Time).

</pre></div>

Historically, the representation of a large portion of the British Nationality Act as a logic program in the 1980s<a href="#cite_note-49">[49]</a> was "hugely influential for the development of computational representations of legislation, showing how logic programming enables intuitively appealing representations that can be directly deployed to generate automatic inferences".<a href="#cite_note-50">[50]</a>

More recently, the PROLEG system,<a href="#cite_note-51">[51]</a> initiated in 2009 and consisting of approximately 2500 rules and exceptions of civil code and supreme court case rules in Japan, has become possibly the largest legal rule base in the world.<a href="#cite_note-:02-52">[52]</a>

<div class="mw-heading mw-heading2"><h2 id="Variants_and_extensions">Variants and extensions</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Prolog">Prolog</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Prolog" title="Prolog">Prolog</a></div>

The SLD resolution rule of inference is neutral about the order in which subgoals in the bodies of clauses can be selected for solution. For the sake of efficiency, Prolog restricts this order to the order in which the subgoals are written. SLD is also neutral about the strategy for searching the space of SLD proofs.

Prolog searches this space, top-down, depth-first, trying different clauses for solving the same (sub)goal in the order in which the clauses are written.

This search strategy has the advantage that the current branch of the tree can be represented efficiently by a <a href="Stack_(abstract_data_type)" title="Stack (abstract data type)">stack</a>. When a goal clause at the top of the stack is reduced to a new goal clause, the new goal clause is pushed onto the top of the stack. When the selected subgoal in the goal clause at the top of the stack cannot be solved, the search strategy <a href="Backtracking" title="Backtracking">backtracks</a>, removing the goal clause from the top of the stack, and retrying the attempted solution of the selected subgoal in the previous goal clause using the next clause that matches the selected subgoal.

Backtracking can be restricted by using a subgoal, called <a href="Cut_(logic_programming)" title="Cut (logic programming)">cut</a>, written as !, which always succeeds but cannot be backtracked. Cut can be used to improve efficiency, but can also interfere with the logical meaning of clauses. In many cases, the use of cut can be replaced by negation as failure. In fact, negation as failure can be defined in Prolog, by using cut, together with any literal, say fail, that unifies with the head of no clause:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>not(P) :- P, !, fail.

not(P).

</pre></div>

Prolog provides other features, in addition to cut, that do not have a logical interpretation. These include the built-in predicates assert and retract for destructively updating the state of the program during program execution.

For example, the <a href="#Knowledge_representation">toy blocks world example above</a> can be implemented without frame axioms using destructive change of state:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>on(green_block, table).

on(red_block, green_block).

move(Object, Place2) :-

retract(on(Object, Place1)),

assert(on(Object, Place2).

</pre></div>

The sequence of move events and the resulting locations of the blocks can be computed by executing the query:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>?- move(red_block, table), move(green_block, red_block), on(Object, Place).

Object = red_block,

Place = table.

Object = green_block,

Place = red_block.

</pre></div>

Various extensions of logic programming have been developed to provide a logical framework for such destructive change of state.<a href="#cite_note-TL-53">[53]</a><a href="#cite_note-54">[54]</a><a href="#cite_note-55">[55]</a>

The broad range of Prolog applications, both in isolation and in combination with other languages is highlighted in the Year of Prolog Book,<a href="#cite_note-Prolog_Book-21">[21]</a> celebrating the 50 year anniversary of Prolog in 2022.

Prolog has also contributed to the development of other programming languages, including <a href="Algebraic_Logic_Functional_programming_language" title="Algebraic Logic Functional programming language">ALF</a>, <a href="Fril" title="Fril">Fril</a>, <a href="G%C3%B6del_(programming_language)" title="Gödel (programming language)">Gödel</a>, <a href="Mercury_programming_language" class="mw-redirect" title="Mercury programming language">Mercury</a>, <a href="Oz_(programming_language)" title="Oz (programming language)">Oz</a>, <a href="Ciao_(programming_language)" title="Ciao (programming language)">Ciao</a>, <a href="Visual_Prolog" title="Visual Prolog">Visual Prolog</a>, <a href="XSB" title="XSB">XSB</a>, and <a href="%CE%9BProlog" title="ΛProlog">λProlog</a>.

<div class="mw-heading mw-heading3"><h3 id="Constraint_logic_programming">Constraint logic programming</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic programming</a></div>

<a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic programming</a> (CLP) combines Horn clause logic programming with <a href="Constraint_solving" class="mw-redirect" title="Constraint solving">constraint solving</a>. It extends Horn clauses by allowing some predicates, declared as constraint predicates, to occur as literals in the body of a clause. Constraint predicates are not defined by the facts and rules in the program, but are predefined by some domain-specific model-theoretic structure or theory.

Procedurally, subgoals whose predicates are defined by the program are solved by goal-reduction, as in ordinary logic programming, but constraints are simplified and checked for satisfiability by a domain-specific constraint-solver, which implements the semantics of the constraint predicates. An initial problem is solved by reducing it to a satisfiable conjunction of constraints.

Interestingly, the first version of Prolog already included a constraint predicate dif(term1, term2), from Philippe Roussel's 1972 PhD thesis, which succeeds if both of its arguments are different terms, but which is delayed if either of the terms contains a variable.<a href="#cite_note-:02-52">[52]</a>

The following constraint logic program represents a toy temporal database of <code>john's</code> history as a teacher:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>teaches(john, hardware, T) :- 1990 ≤ T, T < 1999.

teaches(john, software, T) :- 1999 ≤ T, T < 2005.

teaches(john, logic, T) :- 2005 ≤ T, T ≤ 2012.

rank(john, instructor, T) :- 1990 ≤ T, T < 2010.

rank(john, professor, T) :- 2010 ≤ T, T < 2014.

</pre></div>

Here <code>≤</code> and <code><</code> are constraint predicates, with their usual intended semantics. The following goal clause queries the database to find out when <code>john</code> both taught <code>logic</code> and was a <code>professor</code>:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>?- teaches(john, logic, T), rank(john, professor, T).

</pre></div>

The solution

<code>

2010 ≤ T, T ≤ 2012

</code>

results from simplifying the constraints

<code>

2005 ≤ T, T ≤ 2012, 2010 ≤ T, T < 2014.

</code>

Constraint logic programming has been used to solve problems in such fields as <a href="Civil_engineering" title="Civil engineering">civil engineering</a>, <a href="Mechanical_engineering" title="Mechanical engineering">mechanical engineering</a>, <a href="Digital_circuit" class="mw-redirect" title="Digital circuit">digital circuit</a> verification, <a href="Automated_timetabling" class="mw-redirect" title="Automated timetabling">automated timetabling</a>, <a href="Air_traffic_control" title="Air traffic control">air traffic control</a>, and finance. It is closely related to <a href="Abductive_logic_programming" title="Abductive logic programming">abductive logic programming</a>.

<div class="mw-heading mw-heading3"><h3 id="Datalog">Datalog</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Datalog" title="Datalog">Datalog</a></div>

Datalog is a database definition language, which combines a relational view of data, as in <a href="Relational_database" title="Relational database">relational databases</a>, with a logical view, as in logic programming.

Relational databases use a relational calculus or relational algebra, with <a href="Relational_database#Relational_operations" title="Relational database">relational operations</a>, such as union, intersection, set difference and cartesian product to specify queries, which access a database. Datalog uses logical connectives, such as or, and and not in the bodies of rules to define relations as part of the database itself.

It was recognized early in the development of relational databases that recursive queries cannot be expressed in either relational algebra or relational calculus, and that this defficiency can be remedied by introducing a least-fixed-point operator.<a href="#cite_note-56">[56]</a><a href="#cite_note-57">[57]</a> In contrast, recursive relations can be defined naturally by rules in logic programs, without the need for any new logical connectives or operators.

Datalog differs from more general logic programming by having only constants and variables as terms. Moreover, all facts are variable-free, and rules are restricted, so that if they are executed bottom-up, then the derived facts are also variable-free.

For example, consider the family database:

father_child(charles, william).

father_child(charles, harry).

parent_child(X, Y) :-

mother_child(X, Y).

parent_child(X, Y) :-

father_child(X, Y).

ancestor_descendant(X, Y) :-

parent_child(X, X).

ancestor_descendant(X, Y) :-

ancestor_descendant(X, Z),

ancestor_descendant(Z, Y).

</pre></div>

Bottom-up execution derives the following set of additional facts and terminates:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>parent_child(elizabeth, charles).

parent_child(charles, william).

parent_child(charles, harry).

ancestor_descendant(elizabeth, charles).

ancestor_descendant(charles, william).

ancestor_descendant(charles, harry).

ancestor_descendant(elizabeth, william).

ancestor_descendant(elizabeth, harry).

</pre></div>

Top-down execution derives the same answers to the query:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>?- ancestor_descendant(X, Y).

</pre></div>

But then it goes into an infinite loop. However, top-down execution with <a href="Tabled_logic_programming" title="Tabled logic programming">tabling</a> gives the same answers and terminates without looping.

<div class="mw-heading mw-heading3"><h3 id="Answer_set_programming">Answer set programming</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Answer_Set_Programming" class="mw-redirect" title="Answer Set Programming">Answer Set Programming</a></div>

Like Datalog, Answer Set programming (ASP) is not Turing-complete. Moreover, instead of separating goals (or queries) from the program to be used in solving the goals, ASP treats the whole program as a goal, and solves the goal by generating a stable model that makes the goal true. For this purpose, it uses the <a href="Stable_model_semantics" title="Stable model semantics">stable model semantics</a>, according to which a logic program can have zero, one or more intended models. For example, the following program represents a degenerate variant of the map colouring problem of colouring two countries red or green:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>country(oz).

country(iz).

adjacent(oz, iz).

colour(C, red) :- country(C), not(colour(C, green)).

colour(C, green) :- country(C), not(colour(C, red)).

</pre></div>

The problem has four solutions represented by four stable models:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>country(oz). country(iz). adjacent(oz, iz). colour(oz, red). colour(iz, red).

country(oz). country(iz). adjacent(oz, iz). colour(oz, green). colour(iz, green).

country(oz). country(iz). adjacent(oz, iz). colour(oz, red). colour(iz, green).

</pre></div>

To represent the standard version of the map colouring problem, we need to add a constraint that two adjacent countries cannot be coloured the same colour. In ASP, this constraint can be written as a clause of the form:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>:- country(C1), country(C2), adjacent(C1, C2), colour(C1, X), colour(C2, X).

</pre></div>

With the addition of this constraint, the problem now has only two solutions:

</pre></div>

The addition of constraints of the form <code>:- Body.</code> eliminates models in which <code>Body</code> is true.

Confusingly, constraints in ASP are different from constraints in CLP. Constraints in CLP are predicates that qualify answers to queries (and solutions of goals). Constraints in ASP are clauses that eliminate models that would otherwise satisfy goals. Constraints in ASP are like integrity constraints in databases.

This combination of ordinary logic programming clauses and constraint clauses illustrates the generate-and-test methodology of problem solving in ASP: The ordinary clauses define a search space of possible solutions, and the constraints filter out unwanted solutions.<a href="#cite_note-58">[58]</a>

Most implementations of ASP proceed in two steps: First they instantiate the program in all possible ways, reducing it to a propositional logic program (known as grounding). Then they apply a propositional logic problem solver, such as the <a href="DPLL_algorithm" title="DPLL algorithm">DPLL algorithm</a> or a <a href="Boolean_SAT_solver" class="mw-redirect" title="Boolean SAT solver">Boolean SAT solver</a>. However, some implementations, such as s(CASP)<a href="#cite_note-59">[59]</a> use a goal-directed, top-down, SLD resolution-like procedure without

grounding.

<div class="mw-heading mw-heading3"><h3 id="Abductive_logic_programming">Abductive logic programming</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Abductive_logic_programming" title="Abductive logic programming">Abductive logic programming</a></div>

<a href="Abductive_logic_programming" title="Abductive logic programming">Abductive logic programming</a><a href="#cite_note-60">[60]</a> (ALP), like CLP, extends normal logic programming by allowing the bodies of clauses to contain literals whose predicates are not defined by clauses. In ALP, these predicates are declared as abducible (or assumable), and are used as in <a href="Abductive_reasoning#Logic-based_abduction" title="Abductive reasoning">abductive reasoning</a> to explain observations, or more generally to add new facts to the program (as assumptions) to solve goals.

For example, suppose we are given an initial state in which a red block is on a green block on a table at time 0:

</pre></div>

Suppose we are also given the goal:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>?- holds(on(green_block,red_block), 3), holds(on(red_block,table), 3).

</pre></div>

The goal can represent an observation, in which case a solution is an explanation of the observation. Or the goal can represent a desired future state of affairs, in which case a solution is a plan for achieving the goal.<a href="#cite_note-61">[61]</a>

We can use the rules for cause and effect presented earlier to solve the goal, by treating the <code>happens</code> predicate as abducible:

happens(Event, Time1),

Time2 is Time1 + 1,

initiates(Event, Fact).

holds(Fact, Time2) :-

happens(Event, Time1),

Time2 is Time1 + 1,

holds(Fact, Time1),

terminated(Fact, Time) :-

happens(Event, Time),

terminates(Event, Fact).

</pre></div>

ALP solves the goal by reasoning backwards and adding assumptions to the program, to solve abducible subgoals. In this case there are many alternative solutions, including:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>happens(move(red_block, table), 0).

happens(tick, 1).

</pre></div>

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>happens(tick,0).

</pre></div>

happens(tick, 2).

</pre></div>

Here <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr">tick</code> is an event that marks the passage of time without initiating or terminating any fluents.

There are also solutions in which the two <code>move</code> events happen at the same time. For example:

happens(tick, 1).

happens(tick, 2).

</pre></div>

Such solutions, if not desired, can be removed by adding an integrity constraint, which is like a constraint clause in ASP:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>:- happens(move(Block1, Place), Time), happens(move(Block2, Block1), Time).

</pre></div>

Abductive logic programming has been used for fault diagnosis, planning, natural language processing and machine learning. It has also been used to interpret negation as failure as a form of abductive reasoning.<a href="#cite_note-62">[62]</a>

<div class="mw-heading mw-heading3"><h3 id="Inductive_logic_programming">Inductive logic programming</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Inductive_logic_programming" title="Inductive logic programming">Inductive logic programming</a></div>

Inductive logic programming (ILP) is an approach to <a href="Machine_learning" title="Machine learning">machine learning</a> that <a href="Inductive_reasoning" title="Inductive reasoning">induces</a> logic programs as hypothetical generalisations of positive and negative examples. Given a logic program representing background knowledge and positive examples together with constraints representing negative examples, an ILP system induces a logic program that generalises the positive examples while excluding the negative examples.

ILP is similar to ALP, in that both can be viewed as generating hypotheses to explain observations, and as employing constraints to exclude undesirable hypotheses. But in ALP the hypotheses are variable-free facts, and in ILP the hypotheses are general rules.<a href="#cite_note-63">[63]</a><a href="#cite_note-64">[64]</a>

For example, given only background knowledge of the mother_child and father_child relations, and suitable examples of the grandparent_child relation, current ILP systems can generate the definition of grandparent_child, inventing an auxiliary predicate, which can be interpreted as the parent_child relation:<a href="#cite_note-65">[65]</a>

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>grandparent_child(X, Y):- auxiliary(X, Z), auxiliary(Z, Y).

auxiliary(X, Y):- mother_child(X, Y).

auxiliary(X, Y):- father_child(X, Y).

</pre></div>

Stuart Russell<a href="#cite_note-66">[66]</a> has referred to such invention of new concepts as the most important step needed for reaching human-level AI.

Recent work in ILP, combining logic programming, learning and probability, has given rise to the fields of <a href="Statistical_relational_learning" title="Statistical relational learning">statistical relational learning</a> and <a href="Probabilistic_inductive_logic_programming" class="mw-redirect" title="Probabilistic inductive logic programming">probabilistic inductive logic programming</a>.

<div class="mw-heading mw-heading3"><h3 id="Concurrent_logic_programming">Concurrent logic programming</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Concurrent_logic_programming" title="Concurrent logic programming">Concurrent logic programming</a></div>

Concurrent logic programming integrates concepts of logic programming with <a href="Concurrent_programming" class="mw-redirect" title="Concurrent programming">concurrent programming</a>. Its development was given a big impetus in the 1980s by its choice for the systems programming language of the <a href="Fifth_generation_computer" class="mw-redirect" title="Fifth generation computer">Japanese Fifth Generation Project (FGCS)</a>.<a href="#cite_note-67">[67]</a>

A concurrent logic program is a set of guarded <a href="Horn_clauses" class="mw-redirect" title="Horn clauses">Horn clauses</a> of the form:

The conjunction <code>G1, ... , Gn</code> is called the <a href="Guard_(computer_science)" title="Guard (computer science)">guard</a> of the clause, and | is the commitment operator. Declaratively, guarded Horn clauses are read as ordinary logical implications:

However, procedurally, when there are several clauses whose heads <code>H</code> match a given goal, then all of the clauses are executed in parallel, checking whether their guards <code>G1, ... , Gn</code> hold. If the guards of more than one clause hold, then a committed choice is made to one of the clauses, and execution proceeds with the subgoals <code>B1, ..., Bn</code> of the chosen clause. These subgoals can also be executed in parallel. Thus concurrent logic programming implements a form of "don't care nondeterminism", rather than "don't know nondeterminism".

For example, the following concurrent logic program defines a predicate <code>shuffle(Left, Right, Merge)</code>, which can be used to shuffle two lists <code>Left</code> and <code>Right</code>, combining them into a single list <code>Merge</code> that preserves the ordering of the two lists <code>Left</code> and <code>Right</code>:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>shuffle([], [], []).

shuffle(Left, Right, Merge) :-

Left = [First | Rest] |

Merge = [First | ShortMerge],

shuffle(Rest, Right, ShortMerge).

Right = [First | Rest] |

Merge = [First | ShortMerge],

shuffle(Left, Rest, ShortMerge).

</pre></div>

Here, <code>[]</code> represents the empty list, and <code>[Head | Tail]</code> represents a list with first element <code>Head</code> followed by list <code>Tail</code>, as in Prolog. (Notice that the first occurrence of | in the second and third clauses is the list constructor, whereas the second occurrence of | is the commitment operator.) The program can be used, for example, to shuffle the lists <code>[ace, queen, king]</code> and <code>[1, 4, 2]</code> by invoking the goal clause:

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre>shuffle([ace, queen, king], [1, 4, 2], Merge).

</pre></div>

The program will non-deterministically generate a single solution, for example <code>Merge = [ace, queen, 1, king, 4, 2]</code>.

<a href="Carl_Hewitt" title="Carl Hewitt">Carl Hewitt</a> has argued<a href="#cite_note-Hewitt-68">[68]</a> that, because of the <a href="Indeterminacy_in_concurrent_computation" title="Indeterminacy in concurrent computation">indeterminacy of concurrent computation</a>, concurrent logic programming cannot implement general concurrency. However, according to the logical semantics, any result of a computation of a concurrent logic program is a logical consequence of the program, even though not all logical consequences can be derived.

<div class="mw-heading mw-heading3"><h3 id="Concurrent_constraint_logic_programming">Concurrent constraint logic programming</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Concurrent_constraint_logic_programming" title="Concurrent constraint logic programming">Concurrent constraint logic programming</a></div>

<a href="Concurrent_constraint_logic_programming" title="Concurrent constraint logic programming">Concurrent constraint logic programming</a><a href="#cite_note-69">[69]</a> combines concurrent logic programming and <a href="Constraint_logic_programming" title="Constraint logic programming">constraint logic programming</a>, using constraints to control concurrency. A clause can contain a guard, which is a set of constraints that may block the applicability of the clause. When the guards of several clauses are satisfied, concurrent constraint logic programming makes a committed choice to use only one.

<div class="mw-heading mw-heading3"><h3 id="Higher-order_logic_programming">Higher-order logic programming</h3></div>

Several researchers have extended logic programming with <a href="Higher-order_programming" title="Higher-order programming">higher-order programming</a> features derived from <a href="Higher-order_logic" title="Higher-order logic">higher-order logic</a>, such as predicate variables. Such languages include the Prolog extensions <a href="HiLog" title="HiLog">HiLog</a><a href="#cite_note-hilog-jlp-70">[70]</a> and <a href="%CE%9BProlog" title="ΛProlog">λProlog</a>.<a href="#cite_note-71">[71]</a>

<div class="mw-heading mw-heading3"><h3 id="Linear_logic_programming">Linear logic programming</h3></div>

Basing logic programming within <a href="Linear_logic" title="Linear logic">linear logic</a> has resulted in the design of logic programming languages that are considerably more expressive than those based on classical logic. Horn clause programs can only represent state change by the change in arguments to predicates. In linear logic programming, one can use the ambient linear logic to support state change. Some early designs of logic programming languages based on linear logic include LO,<a href="#cite_note-72">[72]</a> Lolli,<a href="#cite_note-73">[73]</a> ACL,<a href="#cite_note-74">[74]</a> and Forum.<a href="#cite_note-75">[75]</a> Forum provides a goal-directed interpretation of all linear logic.

<div class="mw-heading mw-heading3"><h3 id="Object-oriented_logic_programming">Object-oriented logic programming</h3></div>

<a href="F-logic" title="F-logic">F-logic</a><a href="#cite_note-76">[76]</a> extends logic programming with objects and the frame syntax.

<a href="Logtalk" title="Logtalk">Logtalk</a><a href="#cite_note-77">[77]</a> extends the Prolog programming language with support for objects, protocols, and other OOP concepts. It supports most standard-compliant Prolog systems as backend compilers.

<div class="mw-heading mw-heading3"><h3 id="Transaction_logic_programming">Transaction logic programming</h3></div>

<a href="Transaction_logic" title="Transaction logic">Transaction logic</a><a href="#cite_note-TL-53">[53]</a> is an extension of logic programming with a logical theory of state-modifying updates. It has both a model-theoretic semantics and a procedural one. An implementation of a subset of Transaction logic is available in the <a href="Flora-2" title="Flora-2">Flora-2</a><a href="#cite_note-78">[78]</a> system. Other prototypes are also <a href="Transaction_logic" title="Transaction logic">available</a>.

<ul><li><a href="Automated_theorem_proving" title="Automated theorem proving">Automated theorem proving</a></li>

<li><a href="Boolean_satisfiability_problem" title="Boolean satisfiability problem">Boolean satisfiability problem</a></li>

<li><a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic programming</a></li>

<li><a href="Control_theory" title="Control theory">Control theory</a></li>

<li><a href="Datalog" title="Datalog">Datalog</a></li>

<li><a href="Functional_programming" title="Functional programming">Functional programming</a></li>

<li><a href="Fuzzy_logic" title="Fuzzy logic">Fuzzy logic</a></li>

<li><a href="Inductive_logic_programming" title="Inductive logic programming">Inductive logic programming</a></li>

<li><a href="Linear_logic" title="Linear logic">Linear logic</a></li>

<li><a href="Logic_in_computer_science" title="Logic in computer science">Logic in computer science</a> (includes <a href="Formal_methods" title="Formal methods">Formal methods</a>)</li>

<li>Logic programming languages</li>

<li><a href="Programmable_logic_controller" title="Programmable logic controller">Programmable logic controller</a></li>

<li><a href="Reasoning_system" title="Reasoning system">Reasoning system</a></li>

<li><a href="Rule-based_machine_learning" title="Rule-based machine learning">Rule-based machine learning</a></li>

<li><a href="Satisfiability" title="Satisfiability">Satisfiability</a></li>

<li><a href="Syntax_and_semantics_of_logic_programming" title="Syntax and semantics of logic programming">Syntax and semantics of logic programming</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="Citations">Citations</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFTärnlund1977" class="citation journal cs1">Tärnlund, S.Å. (1977). "Horn clause computability". <a href="BIT_Numerical_Mathematics" title="BIT Numerical Mathematics">BIT Numerical Mathematics</a>. 17 (2): 215–226. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2FBF01932293">10.1007/BF01932293</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:32577496">32577496</a>.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> <cite id="CITEREFAndrékaNémeti1978" class="citation journal cs1">Andréka, H.; Németi, I. (1978). <a rel="nofollow" class="external text" href="https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/3160">"The generalised completeness of Horn predicate-logic as a programming language"</a>. Acta Cybernetica. 4 (1): 3–10.</cite>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite id="CITEREFGreen" class="citation conference cs1">Green, Cordell. <a rel="nofollow" class="external text" href="https://www.ijcai.org/Proceedings/69/Papers/023.pdf">Application of Theorem Proving to Problem Solving</a> (PDF). IJCAI 1969.</cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite id="CITEREFFosterElcock1969" class="citation conference cs1">Foster, J.M.; Elcock, E.W. (1969). ABSYS 1: An Incremental Compiler for Assertions: an Introduction. Fourth Annual Machine Intelligence Workshop. Machine Intelligence. Vol. 4. Edinburgh, UK: <a href="Edinburgh_University_Press" title="Edinburgh University Press">Edinburgh University Press</a>. pp. 423–429.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite id="CITEREFKowalski1988" class="citation journal cs1">Kowalski, R. A. (1988). <a rel="nofollow" class="external text" href="http://www.doc.ic.ac.uk/~rak/papers/the%20early%20years.pdf">"The early years of logic programming"</a> (PDF). Communications of the ACM. 31: 38–43. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F35043.35046">10.1145/35043.35046</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:12259230">12259230</a>.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <cite id="CITEREFHewitt" class="citation conference cs1"><a href="Carl_Hewitt" title="Carl Hewitt">Hewitt, Carl</a>. <a rel="nofollow" class="external text" href="https://www.ijcai.org/Proceedings/69/Papers/030.pdf">Planner: A Language for Proving Theorems in Robots</a> (PDF). IJCAI 1969.</cite>

</li>

<li id="cite_note-Winograd-7"><a href="#cite_ref-Winograd_7-0">^</a> <cite id="CITEREFWinograd1972" class="citation journal cs1"><a href="Terry_Winograd" title="Terry Winograd">Winograd, Terry</a> (1972). "Understanding natural language". <a href="Cognitive_Psychology_(journal)" title="Cognitive Psychology (journal)">Cognitive Psychology</a>. 3 (1): 1–191. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0010-0285%2872%2990002-3">10.1016/0010-0285(72)90002-3</a>.</cite>

</li>

<li id="cite_note-Rulifson-8"><a href="#cite_ref-Rulifson_8-0">^</a> <cite id="CITEREFJeff_RulifsonJan_DerksenRichard_Waldinger1973" class="citation techreport cs1"><a href="Jeff_Rulifson" title="Jeff Rulifson">Jeff Rulifson</a>; Jan Derksen; Richard Waldinger (November 1973). <a rel="nofollow" class="external text" href="https://apps.dtic.mil/sti/pdfs/ADA052440.pdf">QA4, A Procedural Calculus for Intuitive Reasoning</a> (PDF) (Technical report). SRI AI Center Technical Note 73.</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> Davies, J.M., 1971. POPLER: a POP-2 planner. Edinburgh University, Department of Machine Intelligence and Perception.

</li>

<li id="cite_note-10"><a href="#cite_ref-10">^</a> <cite id="CITEREFMcDermottSussman1972" class="citation techreport cs1"><a href="Drew_McDermott" title="Drew McDermott">McDermott, D.V.</a>; <a href="Gerald_Jay_Sussman" title="Gerald Jay Sussman">Sussman, G.J.</a> (May 1972). <a rel="nofollow" class="external text" href="https://www.researchgate.net/publication/37597046_The_Conniver_Reference_Manual">The Conniver reference manual</a> (Technical report). Artificial Intelligence Memo No. 259.</cite>

</li>

<li id="cite_note-11"><a href="#cite_ref-11">^</a> <cite id="CITEREFRebohSacerdoti1973" class="citation techreport cs1">Reboh, R.; Sacerdoti, E.D. (August 1973). <a rel="nofollow" class="external text" href="https://www.sri.com/publication/cyber-formal-methods-pubs/preliminary-qlisp-manual/">A preliminary QLISP manual</a> (Technical report). Artificial Intelligence Center, SRI International.</cite>

</li>

<li id="cite_note-12"><a href="#cite_ref-12">^</a> <cite id="CITEREFKornfeldHewitt1981" class="citation journal cs1">Kornfeld, W.A.; <a href="Carl_Hewitt" title="Carl Hewitt">Hewitt, C.E.</a> (1981). "The scientific community metaphor". IEEE Transactions on Systems, Man, and Cybernetics. 11 (1): 24–33. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1109%2FTSMC.1981.4308575">10.1109/TSMC.1981.4308575</a>. <a href="Hdl_(identifier)" class="mw-redirect" title="Hdl (identifier)">hdl</a>:<a rel="nofollow" class="external text" href="https://hdl.handle.net/1721.1%2F5693">1721.1/5693</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:1322857">1322857</a>.</cite>

</li>

<li id="cite_note-13"><a href="#cite_ref-13">^</a> <cite id="CITEREFHayes1973" class="citation conference cs1">Hayes, Pat (1973). "Computation and Deduction". Proceedings of the 2nd MFCS Symposium. <a href="Czechoslovak_Academy_of_Sciences" title="Czechoslovak Academy of Sciences">Czechoslovak Academy of Sciences</a>. pp. 105–118.</cite>

</li>

<li id="cite_note-14"><a href="#cite_ref-14">^</a> <cite id="CITEREFRobinson1965" class="citation journal cs1">Robinson, J. (1965). "Automatic deduction with hyper-resolution". <a href="International_Journal_of_Computer_Mathematics" title="International Journal of Computer Mathematics">International Journal of Computer Mathematics</a>. 1 (3): 227–234. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.2307%2F2272384">10.2307/2272384</a>. <a href="JSTOR_(identifier)" class="mw-redirect" title="JSTOR (identifier)">JSTOR</a> <a rel="nofollow" class="external text" href="https://www.jstor.org/stable/2272384">2272384</a>.</cite>

</li>

<li id="cite_note-15"><a href="#cite_ref-15">^</a> <cite id="CITEREFKowalskiKuehner1971" class="citation journal cs1">Kowalski, Robert; Kuehner, Donald (1971). <a rel="nofollow" class="external text" href="http://www.doc.ic.ac.uk/~rak/papers/sl.pdf">"Linear Resolution with Selection Function"</a> (PDF). <a href="Artificial_Intelligence_(journal)" title="Artificial Intelligence (journal)">Artificial Intelligence</a>. 2 (3–4): 227–260. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0004-3702%2871%2990012-9">10.1016/0004-3702(71)90012-9</a>.</cite>

</li>

<li id="cite_note-Kowalski-16"><a href="#cite_ref-Kowalski_16-0">^</a> <cite id="CITEREFKowalski1973" class="citation web cs1">Kowalski, Robert (1973). <a rel="nofollow" class="external text" href="https://www.doc.ic.ac.uk/~rak/papers/IFIP%2074.pdf">"Predicate Logic as a Programming Language"</a> (PDF). Department of Artificial Intelligence, <a href="Edinburgh_University" class="mw-redirect" title="Edinburgh University">Edinburgh University</a>. Memo 70.</cite> Also in Proceedings IFIP Congress, Stockholm, North Holland Publishing Co., 1974, pp. 569–574.

</li>

<li id="cite_note-17"><a href="#cite_ref-17">^</a> <cite id="CITEREFWarrenPereiraPereira1977" class="citation journal cs1">Warren, D.H.; Pereira, L.M.; Pereira, F. (1977). "Prolog-the language and its implementation compared with Lisp". <a href="ACM_SIGPLAN_Notices" class="mw-redirect" title="ACM SIGPLAN Notices">ACM SIGPLAN Notices</a>. 12 (8): 109–115. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F872734.806939">10.1145/872734.806939</a>.</cite>

</li>

<li id="cite_note-18"><a href="#cite_ref-18">^</a> Ueda, K., 2018. Logic/constraint programming and concurrency: The hard-won lessons of the fifth generation computer project. Science of Computer Programming, 164, pp.3-17.

</li>

<li id="cite_note-19"><a href="#cite_ref-19">^</a> H.P. Newquist, 2020. The Brain Makers: The History Of Artificial Intelligence. The Relayer Group.

</li>

<li id="cite_note-20"><a href="#cite_ref-20">^</a> <cite id="CITEREFGallaireMinker1978" class="citation cs2">Gallaire, Hervé; Minker, John 'Jack', eds. (1978), "Logic and Data Bases, Symposium on Logic and Data Bases, Centre d'études et de recherches de Toulouse, 1977", <a rel="nofollow" class="external text" href="https://archive.org/details/logicdatabases0000symp">Advances in Data Base Theory</a>, New York: Plenum Press, <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-306-40060-5</bdi></cite>.

</li>

<li id="cite_note-Prolog_Book-21">^ <a href="#cite_ref-Prolog_Book_21-0">a</a> <a href="#cite_ref-Prolog_Book_21-1">b</a> <cite id="CITEREFWarren2023" class="citation book cs1">Warren, D.S. (2023). "Introduction to Prolog". In Warren, D.S.; Dahl, V.; Eiter, T.; Hermenegildo, M.V.; Kowalski, R.; Rossi, F. (eds.). Prolog: The Next 50 Years. Lecture Notes in Computer Science(). Vol. 13900. Springer, Cham. pp. 3–19. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2F978-3-031-35254-6_1">10.1007/978-3-031-35254-6_1</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-3-031-35253-9</bdi>.</cite>

</li>

<li id="cite_note-22"><a href="#cite_ref-22">^</a> <cite id="CITEREFRobinson2001" class="citation journal cs1">Robinson, J. Alan (2001). <a rel="nofollow" class="external text" href="https://doi.org/10.1017%2Fs1471068400000028">"Invited Editorial"</a>. Theory and Practice of Logic Programming. 1 (1). <a href="Cambridge_University_Press" title="Cambridge University Press">Cambridge University Press</a>: 1. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1017%2Fs1471068400000028">10.1017/s1471068400000028</a>.</cite>

</li>

<li id="cite_note-23"><a href="#cite_ref-23">^</a> <cite id="CITEREFR.A.Kowalski1979" class="citation journal cs1">R.A.Kowalski (July 1979). <a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F359131.359136">"Algorithm=Logic + Control"</a>. <a href="Communications_of_the_ACM" title="Communications of the ACM">Communications of the ACM</a>. 22 (7): 424–436. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F359131.359136">10.1145/359131.359136</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:2509896">2509896</a>.</cite>

</li>

<li id="cite_note-24"><a href="#cite_ref-24">^</a> <cite id="CITEREFBruynooghePereira1984" class="citation book cs1">Bruynooghe, M.; Pereira, L.M. (1984). "Deduction revision by intelligent backtracking". Implementations of Prolog. Chichester, England: Ellis Horwood. pp. 194–215.</cite>

</li>

<li id="cite_note-25"><a href="#cite_ref-25">^</a> <cite id="CITEREFNakamura1985" class="citation conference cs1">Nakamura, K. (July 1985). Heuristic Prolog: logic program execution by heuristic search. Conference on Logic Programming. Berlin, Heidelberg: Springer Berlin Heidelberg. pp. 148–155.</cite>

</li>

<li id="cite_note-26"><a href="#cite_ref-26">^</a> <cite id="CITEREFGeneserethGinsberg1985" class="citation journal cs1">Genesereth, M.R.; Ginsberg, M.L. (1985). <a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F4284.4287">"Logic programming"</a>. <a href="Communications_of_the_ACM" title="Communications of the ACM">Communications of the ACM</a>. 28 (9): 933–941. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F4284.4287">10.1145/4284.4287</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:15527861">15527861</a>.</cite>

</li>

<li id="cite_note-27"><a href="#cite_ref-27">^</a> <cite id="CITEREFSwiftWarren2012" class="citation journal cs1">Swift, T.; Warren, D.S. (January 2012). "XSB: Extending Prolog with tabled logic programming". <a href="Theory_and_Practice_of_Logic_Programming" class="mw-redirect" title="Theory and Practice of Logic Programming">Theory and Practice of Logic Programming</a>. 12 (1–2): 157–187. <a href="ArXiv_(identifier)" class="mw-redirect" title="ArXiv (identifier)">arXiv</a>:<a rel="nofollow" class="external text" href="https://arxiv.org/abs/1012.5123">1012.5123</a>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1017%2FS1471068411000500">10.1017/S1471068411000500</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:6153112">6153112</a>.</cite>

</li>

<li id="cite_note-dis-28">^ <a href="#cite_ref-dis_28-0">a</a> <a href="#cite_ref-dis_28-1">b</a> <cite id="CITEREFDaniel_FriedmanWilliam_ByrdOleg_KiselyovJason_Hemann2018" class="citation book cs1">Daniel Friedman; William Byrd; Oleg Kiselyov; Jason Hemann (2018). The Reasoned Schemer, Second Edition. The MIT Press.</cite>

</li>

<li id="cite_note-29"><a href="#cite_ref-29">^</a> A. Casas, D. Cabeza, M. V. Hermenegildo. A Syntactic Approach to

Combining Functional Notation, Lazy Evaluation and Higher-Order in

LP Systems. The 8th International Symposium on Functional and Logic Programming (FLOPS'06), pages 142-162, April 2006.

</li>

<li id="cite_note-30"><a href="#cite_ref-30">^</a> Kersting, K., Mladenov, M. and Tokmakov, P., 2017. Relational linear programming. Artificial Intelligence, 244, pp.188-216.

</li>

<li id="cite_note-31"><a href="#cite_ref-31">^</a> Beyer, D., 2006, May. Relational programming with CrocoPat. In Proceedings of the 28th International Conference on Software engineering (pp. 807-810).

</li>

<li id="cite_note-32"><a href="#cite_ref-32">^</a> <cite id="CITEREFMacLennan1983" class="citation journal cs1">MacLennan, Bruce James (March 1983). <a href="Richard_Wexelblat" title="Richard Wexelblat">Wexelblat, Richard L.</a> (ed.). <a rel="nofollow" class="external text" href="https://dl.acm.org/doi/10.1145/988209.988213">"Overview of relational programming"</a>. ACM SIGPLAN Notices. 18 (3). New York, NY: Association for Computing Machinery: 36–45. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F988209.988213">10.1145/988209.988213</a>. <a href="Hdl_(identifier)" class="mw-redirect" title="Hdl (identifier)">hdl</a>:<a rel="nofollow" class="external text" href="https://hdl.handle.net/10945%2F29034">10945/29034</a>. <a href="ISSN_(identifier)" class="mw-redirect" title="ISSN (identifier)">ISSN</a> <a rel="nofollow" class="external text" href="https://search.worldcat.org/issn/0362-1340">0362-1340</a>. <a href="OCLC_(identifier)" class="mw-redirect" title="OCLC (identifier)">OCLC</a> <a rel="nofollow" class="external text" href="https://search.worldcat.org/oclc/25073822">25073822</a>. Retrieved 8 May 2025.</cite>

</li>

<li id="cite_note-33"><a href="#cite_ref-33">^</a> Behnke, R., Berghammer, R., Meyer, E. and Schneider, P., 1998. RELVIEW—A system for calculating with relations and relational programming. In Fundamental Approaches to Software Engineering: First International Conference, FASE'98 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS'98 Lisbon, Portugal, March 28–April 4, 1998 Proceedings 1 (pp. 318-321). Springer Berlin Heidelberg.

</li>

<li id="cite_note-34"><a href="#cite_ref-34">^</a> <cite id="CITEREFVan_EmdenKowalski1976" class="citation journal cs1">Van Emden, M.H.; Kowalski, R.A. (October 1976). <a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F321978.321991">"The semantics of predicate logic as a programming language"</a>. <a href="Journal_of_the_ACM" title="Journal of the ACM">Journal of the ACM</a>. 23 (4): 733–742. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F321978.321991">10.1145/321978.321991</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:11048276">11048276</a>.</cite>

</li>

<li id="cite_note-35"><a href="#cite_ref-35">^</a> <cite id="CITEREFClark1977" class="citation book cs1"><a href="Keith_Clark_(computer_scientist)" title="Keith Clark (computer scientist)">Clark, K.L.</a> (1977). "Negation as Failure". Logic and Data Bases. Boston, MA: Springer US. pp. 293–322. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2F978-1-4684-3384-5_11">10.1007/978-1-4684-3384-5_11</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1-4684-3386-9</bdi>.</cite>

</li>

<li id="cite_note-36"><a href="#cite_ref-36">^</a> <cite id="CITEREFGelfondPrzymusinskaPrzymusinski1989" class="citation journal cs1">Gelfond, M.; Przymusinska, H.; Przymusinski, T. (1989). "On the relationship between circumscription and negation as failure". <a href="Artificial_Intelligence_(journal)" title="Artificial Intelligence (journal)">Artificial Intelligence</a>. 38 (1): 75–94. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0004-3702%2889%2990068-4">10.1016/0004-3702(89)90068-4</a>.</cite>

</li>

<li id="cite_note-37"><a href="#cite_ref-37">^</a> <cite id="CITEREFShepherdson1984" class="citation journal cs1">Shepherdson, J.C. (1984). "Negation as failure: a comparison of Clark's completed data base and Reiter's closed world assumption". <a href="The_Journal_of_Logic_Programming" class="mw-redirect" title="The Journal of Logic Programming">The Journal of Logic Programming</a>. 1 (1): 51–79. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0743-1066%2884%2990023-2">10.1016/0743-1066(84)90023-2</a>.</cite>

</li>

<li id="cite_note-38"><a href="#cite_ref-38">^</a> <cite id="CITEREFDeneckerTernovska2008" class="citation journal cs1">Denecker, M.; Ternovska, E. (2008). <a rel="nofollow" class="external text" href="https://lirias.kuleuven.be/handle/123456789/222628">"A logic of nonmonotone inductive definitions"</a>. <a href="ACM_Transactions_on_Computational_Logic" title="ACM Transactions on Computational Logic">ACM Transactions on Computational Logic</a>. 9 (2): 14:1–14:52. <a href="ArXiv_(identifier)" class="mw-redirect" title="ArXiv (identifier)">arXiv</a>:<a rel="nofollow" class="external text" href="https://arxiv.org/abs/cs/0501025">cs/0501025</a>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F1342991.1342998">10.1145/1342991.1342998</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:13156469">13156469</a>.</cite>

</li>

<li id="cite_note-39"><a href="#cite_ref-39">^</a> <cite id="CITEREFRaoSagonasSwiftWarren1997" class="citation conference cs1">Rao, P.; Sagonas, K.; Swift, T.; Warren, D.S.; Freire, J. (July 28–31, 1997). XSB: A system for efficiently computing well-founded semantics. Logic Programming And Nonmonotonic Reasoning: 4th International Conference, LPNMR'97. Dagstuhl Castle, Germany: Springer Berlin Heidelberg. pp. 430–440. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2F3-540-63255-7_33">10.1007/3-540-63255-7_33</a>.</cite>

</li>

<li id="cite_note-40"><a href="#cite_ref-40">^</a> <cite id="CITEREFW._ChenD._S._Warren1996" class="citation journal cs1">W. Chen; D. S. Warren (January 1996). <a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F227595.227597">"Tabled Evaluation with Delaying for General Logic Programs"</a>. <a href="Journal_of_the_ACM" title="Journal of the ACM">Journal of the ACM</a>. 43 (1): 20–74. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F227595.227597">10.1145/227595.227597</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:7041379">7041379</a>.</cite>

</li>

<li id="cite_note-41"><a href="#cite_ref-41">^</a> <cite id="CITEREFPhan_Minh_Dung1995" class="citation journal cs1">Phan Minh Dung (1995). <a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0004-3702%2894%2900041-X">"On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming, and n–person games"</a>. Artificial Intelligence. 77 (2): 321–357. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0004-3702%2894%2900041-X">10.1016/0004-3702(94)00041-X</a>.</cite>

</li>

<li id="cite_note-42"><a href="#cite_ref-42">^</a> Colmerauer, A. and Roussel, P., 1996. The birth of Prolog. In History of programming languages---II (pp. 331-367).

</li>

<li id="cite_note-Warren-43">^ <a href="#cite_ref-Warren_43-0">a</a> <a href="#cite_ref-Warren_43-1">b</a> Warren, D.H., Pereira, L.M. and Pereira, F., 1977. Prolog-the language and its implementation compared with Lisp. ACM SIGPLAN Notices, 12(8), pp.109-115.

</li>

<li id="cite_note-44"><a href="#cite_ref-44">^</a> <cite id="CITEREFThagard2005" class="citation book cs1">Thagard, Paul (2005). Mind: Introduction to Cognitive Science. The MIT Press. p. 11. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>9780262701099</bdi>.</cite><a rel="nofollow" class="external free" href="https://www.google.co.uk/books/edition/Mind_second_edition/gjcR1U2HT7kC?hl=en&gbpv=1&pg=PP11&printsec=frontcover">https://www.google.co.uk/books/edition/Mind_second_edition/gjcR1U2HT7kC?hl=en&gbpv=1&pg=PP11&printsec=frontcover</a>

</li>

<li id="cite_note-45"><a href="#cite_ref-45">^</a> <cite id="CITEREFStenningvan_Lambalgen,_Michiel2008" class="citation book cs1">Stenning, Keith; van Lambalgen, Michiel (2008). <a rel="nofollow" class="external text" href="https://archive.org/details/humanreasoni_sten_2008_000_10735669">Human reasoning and cognitive science</a>. <a href="MIT_Press" title="MIT Press">MIT Press</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-262-19583-6</bdi>.</cite><a rel="nofollow" class="external free" href="https://philpapers.org/archive/STEHRA-5.pdf">https://philpapers.org/archive/STEHRA-5.pdf</a>

</li>

<li id="cite_note-46"><a href="#cite_ref-46">^</a> Van Lambalgen, M. and Hamm, F., 2008. The proper treatment of events. John Wiley & Sons.

<a rel="nofollow" class="external free" href="https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=3126320bb6e37ca3727fed404828b53fc56ff063">https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=3126320bb6e37ca3727fed404828b53fc56ff063</a>

</li>

<li id="cite_note-47"><a href="#cite_ref-47">^</a> Reiter, R., 1991. The frame problem in the situation calculus: A simple solution (sometimes) and a completeness result for goal regression. Artificial and Mathematical Theory of Computation, 3.

</li>

<li id="cite_note-48"><a href="#cite_ref-48">^</a> Merritt, D., 2012. Building expert systems in Prolog. Springer Science & Business Media. <a rel="nofollow" class="external free" href="https://ds.amu.edu.et/xmlui/bitstream/handle/123456789/4434/%28Text%20Book%29%20Building%20Expert%20Systems%20in%20Prolog.pdf?sequence=1&isAllowed=y">https://ds.amu.edu.et/xmlui/bitstream/handle/123456789/4434/%28Text%20Book%29%20Building%20Expert%20Systems%20in%20Prolog.pdf?sequence=1&isAllowed=y</a>

</li>

<li id="cite_note-49"><a href="#cite_ref-49">^</a> <cite id="CITEREFSergotSadriKowalskiKriwaczek1986" class="citation journal cs1">Sergot, M.J.; Sadri, F.; Kowalski, R.A.; Kriwaczek, F.; Hammond, P; Cory, H.T. (1986). <a rel="nofollow" class="external text" href="http://www.doc.ic.ac.uk/~rak/papers/British%20Nationality%20Act.pdf">"The British Nationality Act as a logic program"</a> (PDF). <a href="Communications_of_the_ACM" title="Communications of the ACM">Communications of the ACM</a>. 29 (5): 370–386. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F5689.5920">10.1145/5689.5920</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:5665107">5665107</a>.</cite>

</li>

<li id="cite_note-50"><a href="#cite_ref-50">^</a> <cite id="CITEREFPrakkenSartor2015" class="citation journal cs1">Prakken, H.; Sartor, G. (October 2015). <a rel="nofollow" class="external text" href="https://www.sciencedirect.com/science/article/pii/S0004370215000910/pdfft?md5=4dc0cf07e5c2a6926d285431b987a859&pid=1-s2.0-S0004370215000910-main.pdf">"Law and logic: a review from an argumentation perspective"</a> (PDF). <a href="Artificial_Intelligence_(journal)" title="Artificial Intelligence (journal)">Artificial Intelligence</a>. 227: 214–245. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2Fj.artint.2015.06.005">10.1016/j.artint.2015.06.005</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:4261497">4261497</a>.</cite>

</li>

<li id="cite_note-51"><a href="#cite_ref-51">^</a> Satoh, K., 2023. PROLEG: Practical legal reasoning system. In Prolog: The Next 50 Years (pp. 277-283). Cham: Springer Nature Switzerland.

</li>

<li id="cite_note-:02-52">^ <a href="#cite_ref-:02_52-0">a</a> <a href="#cite_ref-:02_52-1">b</a> <cite id="CITEREFKörnerLeuschelBarbosaCosta2022" class="citation journal cs1">Körner, Philipp; Leuschel, Michael; Barbosa, João; Costa, Vítor Santos; Dahl, Verónica; Hermenegildo, Manuel V.; Morales, Jose F.; Wielemaker, Jan; Diaz, Daniel; Abreu, Salvador; Ciatto, Giovanni (November 2022). <a rel="nofollow" class="external text" href="https://doi.org/10.1017%2FS1471068422000102">"Fifty Years of Prolog and Beyond"</a>. Theory and Practice of Logic Programming. 22 (6): 776–858. <a href="ArXiv_(identifier)" class="mw-redirect" title="ArXiv (identifier)">arXiv</a>:<a rel="nofollow" class="external text" href="https://arxiv.org/abs/2201.10816">2201.10816</a>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1017%2FS1471068422000102">10.1017/S1471068422000102</a>. <a href="ISSN_(identifier)" class="mw-redirect" title="ISSN (identifier)">ISSN</a> <a rel="nofollow" class="external text" href="https://search.worldcat.org/issn/1471-0684">1471-0684</a>.</cite>

</li>

<li id="cite_note-TL-53">^ <a href="#cite_ref-TL_53-0">a</a> <a href="#cite_ref-TL_53-1">b</a> Bonner, A.J. and Kifer, M., 1993, February. Transaction Logic Programming. In ICLP (Vol. 93, pp. 257-279).

</li>

<li id="cite_note-54"><a href="#cite_ref-54">^</a> Genesereth, M., 2023. Dynamic logic programming. In Prolog: The Next 50 Years (pp. 197-209). Cham: Springer Nature Switzerland.

</li>

<li id="cite_note-55"><a href="#cite_ref-55">^</a> Kowalski, R., Sadri, F., Calejo, M. and Dávila, J., 2023. Combining logic programming and imperative programming in LPS. In Prolog: The Next 50 Years (pp. 210-223). Cham: Springer Nature Switzerland.

</li>

<li id="cite_note-56"><a href="#cite_ref-56">^</a> Aho, A.V. and Ullman, J.D., 1979, January. Universality of data retrieval languages. In Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languages (pp. 110-119).

</li>

<li id="cite_note-57"><a href="#cite_ref-57">^</a> Maier, D., Tekle, K.T., Kifer, M. and Warren, D.S., 2018. Datalog: concepts, history, and outlook. In Declarative Logic Programming: Theory, Systems, and Applications (pp. 3-100).

</li>

<li id="cite_note-58"><a href="#cite_ref-58">^</a> Eiter, T., Ianni, G. and Krennwallner, T., 2009. Answer Set Programming: A Primer. In Reasoning Web. Semantic Technologies for Information Systems: 5th International Summer School 2009, Brixen-Bressanone, Italy, August 30-September 4, 2009, Tutorial Lectures (pp. 40-110).

</li>

<li id="cite_note-59"><a href="#cite_ref-59">^</a> <cite id="CITEREFAriasCarroSalazarMarple2018" class="citation journal cs1">Arias, J.; Carro, M.; Salazar, E.; Marple, K.; Gupta, G. (2018). <a rel="nofollow" class="external text" href="https://doi.org/10.1017%2FS1471068418000285">"Constraint Answer Set Programming without Grounding"</a>. Theory and Practice of Logic Programming. 18 (3–4): 337–354. <a href="ArXiv_(identifier)" class="mw-redirect" title="ArXiv (identifier)">arXiv</a>:<a rel="nofollow" class="external text" href="https://arxiv.org/abs/1804.11162">1804.11162</a>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1017%2FS1471068418000285">10.1017/S1471068418000285</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:13754645">13754645</a>.</cite>

</li>

<li id="cite_note-60"><a href="#cite_ref-60">^</a> <cite id="CITEREFDeneckerKakas2000" class="citation journal cs1">Denecker, M.; Kakas, A.C. (July 2000). <a rel="nofollow" class="external text" href="https://doi.org/10.1016%2FS0743-1066%2899%2900078-3">"Special issue: abductive logic programming"</a>. Journal of Logic Programming. 44 (1–3): 1–4. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2FS0743-1066%2899%2900078-3">10.1016/S0743-1066(99)00078-3</a>.</cite>

</li>

<li id="cite_note-61"><a href="#cite_ref-61">^</a> Eshghi, K., 1988, August. Abductive Planning with Event Calculus. In ICLP/SLP (pp. 562-579).

</li>

<li id="cite_note-62"><a href="#cite_ref-62">^</a> Eshghi, K. and Kowalski, R.A., 1989, June. Abduction Compared with Negation by Failure. In ICLP (Vol. 89, pp. 234-255).

</li>

<li id="cite_note-63"><a href="#cite_ref-63">^</a> <cite id="CITEREFNienhuys-ChengWolf1997" class="citation book cs1">Nienhuys-Cheng, Shan-hwei; Wolf, Ronald de (1997). Foundations of inductive logic programming. Lecture notes in computer science Lecture notes in artificial intelligence. Berlin Heidelberg: Springer. p. 173. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-3-540-62927-6</bdi>.</cite>

</li>

<li id="cite_note-64"><a href="#cite_ref-64">^</a> Flach, P.A. and Kakas, A.C., 2000. On the relation between abduction and inductive learning. In Abductive Reasoning and Learning (pp. 1-33). Dordrecht: Springer Netherlands.

</li>

<li id="cite_note-65"><a href="#cite_ref-65">^</a> Cropper, A. and Dumančić, S., 2022. Inductive logic programming at 30: a new introduction. Journal of Artificial Intelligence Research, 74, pp.765-850.

</li>

<li id="cite_note-66"><a href="#cite_ref-66">^</a> Russell, S., 2019. Human compatible: Artificial intelligence and the problem of control. Penguin.

</li>

<li id="cite_note-67"><a href="#cite_ref-67">^</a> Shunichi Uchida and Kazuhiro Fuchi. Proceedings of the FGCS Project Evaluation Workshop. Institute for New Generation Computer Technology (ICOT). 1992.

</li>

<li id="cite_note-Hewitt-68"><a href="#cite_ref-Hewitt_68-0">^</a> <cite id="CITEREFHewitt,_Carl2016" class="citation web cs1">Hewitt, Carl (27 April 2016). <a rel="nofollow" class="external text" href="https://hal.archives-ouvertes.fr/hal-01148496v6/document">"Inconsistency Robustness for Logic Programs"</a>. Hal Archives. pp. 21–26. Retrieved 7 November 2016.</cite>

</li>

<li id="cite_note-69"><a href="#cite_ref-69">^</a> Saraswat, V.A. and Rinard, M., 1989, December. Concurrent constraint programming. In Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (pp. 232-245).

</li>

<li id="cite_note-hilog-jlp-70"><a href="#cite_ref-hilog-jlp_70-0">^</a> <cite id="CITEREFChenKiferWarren1993" class="citation journal cs1">Chen, Weidong; Kifer, Michael; Warren, David S. (February 1993). <a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0743-1066%2893%2990039-J">"HiLog: A foundation for higher-order logic programming"</a>. <a href="Journal_of_Logic_Programming" class="mw-redirect" title="Journal of Logic Programming">Journal of Logic Programming</a>. 15 (3): 187–230. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0743-1066%2893%2990039-J">10.1016/0743-1066(93)90039-J</a>.</cite>

</li>

<li id="cite_note-71"><a href="#cite_ref-71">^</a> Miller, D.A. and Nadathur, G., 1986, July. Higher-order logic programming. In International Conference on Logic Programming (pp. 448-462). Berlin, Heidelberg: Springer Berlin Heidelberg.

</li>

<li id="cite_note-72"><a href="#cite_ref-72">^</a> <cite id="CITEREFAndreoli1992" class="citation journal cs1">Andreoli, Jean-Marc (1 June 1992). "Logic Programming with Focusing Proofs in Linear Logic". <a href="Journal_of_Logic_and_Computation" title="Journal of Logic and Computation">Journal of Logic and Computation</a>. 2 (3): 297–347. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1093%2Flogcom%2F2.3.297">10.1093/logcom/2.3.297</a>.</cite>

</li>

<li id="cite_note-73"><a href="#cite_ref-73">^</a> <cite id="CITEREFHodasMiller1994" class="citation journal cs1">Hodas, Joshua; Miller, Dale (1994). <a rel="nofollow" class="external text" href="http://repository.upenn.edu/cgi/viewcontent.cgi?article=1540&context=cis_reports">"Logic Programming in a Fragment of Intuitionistic Linear Logic"</a>. <a href="Information_and_Computation" title="Information and Computation">Information and Computation</a>. 110 (2): 327–365. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1006%2Finco.1994.1036">10.1006/inco.1994.1036</a>.</cite>

</li>

<li id="cite_note-74"><a href="#cite_ref-74">^</a> <cite id="CITEREFKobayashiYonezawa1994" class="citation conference cs1">Kobayashi, Naoki; <a href="Akinori_Yonezawa" title="Akinori Yonezawa">Yonezawa, Akinori</a> (1994). Asynchronous communication model based on linear logic. US/Japan Workshop on Parallel Symbolic Computing. pp. 279–294. <a href="CiteSeerX_(identifier)" class="mw-redirect" title="CiteSeerX (identifier)">CiteSeerX</a> <a rel="nofollow" class="external text" href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.8749">10.1.1.42.8749</a>.</cite>

</li>

<li id="cite_note-75"><a href="#cite_ref-75">^</a> <cite id="CITEREFMiller1996" class="citation journal cs1">Miller, Dale (30 September 1996). <a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0304-3975%2896%2900045-X">"Forum: A Multiple-Conclusion Specification Logic"</a>. <a href="Theoretical_Computer_Science_(journal)" title="Theoretical Computer Science (journal)">Theoretical Computer Science</a>. 165 (1): 201–232. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0304-3975%2896%2900045-X">10.1016/0304-3975(96)00045-X</a>.</cite>

</li>

<li id="cite_note-76"><a href="#cite_ref-76">^</a> Kifer, M. and Lausen, G., 1989, June. F-logic: a higher-order language for reasoning about objects, inheritance, and scheme. In Proceedings of the 1989 ACM SIGMOD international conference on Management of data (pp. 134-146).

</li>

<li id="cite_note-77"><a href="#cite_ref-77">^</a> de Moura, P.J.L., 2003. Design of an Object-Oriented Logic Programming Language (Doctoral dissertation, Universidade da Beira Interior).

</li>

<li id="cite_note-78"><a href="#cite_ref-78">^</a> Yang, G. and Kifer, M., 2000, July. FLORA: Implementing an efficient DOOD system using a tabling logic engine. In International Conference on Computational Logic (pp. 1078-1093). Berlin, Heidelberg: Springer Berlin Heidelberg.

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="Sources">Sources</h2></div>

<div class="mw-heading mw-heading3"><h3 id="General_introductions">General introductions</h3></div>

<ul><li><cite id="CITEREFBaralGelfond1994" class="citation journal cs1 cs1-prop-long-vol">Baral, C.; Gelfond, M. (1994). <a rel="nofollow" class="external text" href="http://redwood.cs.ttu.edu/~mgelfond/PAPERS/survey.pdf">"Logic programming and knowledge representation"</a> (PDF). The Journal of Logic Programming. 19–20: 73–148. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0743-1066%2894%2990025-6">10.1016/0743-1066(94)90025-6</a>.</cite></li>

<li><cite id="CITEREFKowalski1988" class="citation journal cs1">Kowalski, R. A. (1988). <a rel="nofollow" class="external text" href="http://www.doc.ic.ac.uk/~rak/papers/the%20early%20years.pdf">"The early years of logic programming"</a> (PDF). Communications of the ACM. 31: 38–43. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F35043.35046">10.1145/35043.35046</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:12259230">12259230</a>.</cite> <a rel="nofollow" class="external autonumber" href="http://www.doc.ic.ac.uk/~rak/papers/the%20early%20years.pdf">[1]</a></li>

<li><cite id="CITEREFLloyd1987" class="citation book cs1">Lloyd, J. W. (1987). Foundations of Logic Programming (2nd ed.). Springer-Verlag.</cite></li></ul>

<div class="mw-heading mw-heading3"><h3 id="Other_sources">Other sources</h3></div>

<ul><li>John McCarthy. <a rel="nofollow" class="external text" href="http://www.cs.rit.edu/~rlaz/is2014/files/McCarthyProgramsWithCommonSense.pdf">"Programs with common sense"</a>. Symposium on Mechanization of Thought Processes. National Physical Laboratory. Teddington, England. 1958.</li>

<li><cite id="CITEREFMillerNadathurPfenningScedrov1991" class="citation journal cs1">Miller, Dale; Nadathur, Gopalan; Pfenning, Frank; Scedrov, Andre (1991). <a rel="nofollow" class="external text" href="https://repository.upenn.edu/cis_reports/711">"Uniform proofs as a foundation for logic programming"</a>. Annals of Pure and Applied Logic. 51 (1–2): 125–157. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0168-0072%2891%2990068-W">10.1016/0168-0072(91)90068-W</a>.</cite></li>

<li>Ehud Shapiro (Editor). Concurrent Prolog. MIT Press. 1987.</li>

<li>James Slagle. <a rel="nofollow" class="external text" href="https://dl.acm.org/doi/abs/10.1145/365691.365960">"Experiments with a Deductive Question-Answering Program"</a>. CACM. December 1965.</li>

<li><a href="Dov_Gabbay" title="Dov Gabbay">Gabbay, Dov M.</a>; Hogger, Christopher John; Robinson, J.A., eds. (1993-1998). <a rel="nofollow" class="external text" href="https://www.worldcat.org/oclc/26300491">Handbook of Logic in Artificial Intelligence and Logic Programming</a>.Vols. 1–5, Oxford University Press.</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Further_reading">Further reading</h2></div>

<ul><li>Carl Hewitt. "<a rel="nofollow" class="external text" href="https://www.ijcai.org/Proceedings/71/Papers/014%20A.pdf">Procedural Embedding of Knowledge in Planner</a>". IJCAI 1971.</li>

<li>Carl Hewitt. "<a rel="nofollow" class="external text" href="https://web.archive.org/web/20170102172145/https://pdfs.semanticscholar.org/9993/ec68770faaab132da6945492b0e4ad07eb7b.pdf">The Repeated Demise of Logic Programming and Why It Will Be Reincarnated</a>". AAAI Spring Symposium: What Went Wrong and Why: Lessons from AI Research and Applications 2006: 2–9.</li>

<li>Evgeny Dantsin, Thomas Eiter, Georg Gottlob, Andrei Voronkov: <a rel="nofollow" class="external text" href="http://cmpe.emu.edu.tr/bayram/courses/531/forpresentation/p374-dantsin.pdf">Complexity and expressive power of logic programming</a>. ACM Comput. Surv. 33(3): 374–425 (2001)</li>

<li>Ulf Nilsson and Jan Maluszynski, <a rel="nofollow" class="external text" href="http://www.ida.liu.se/~ulfni/lpp/">Logic, Programming and Prolog</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .side-box{margin:4px 0;box-sizing:border-box;border:1px solid #aaa;font-size:88%;line-height:1.25em;background-color:var(--background-color-interactive-subtle,#f8f9fa);display:flow-root}.mw-parser-output .infobox .side-box{font-size:100%}.mw-parser-output .side-box-abovebelow,.mw-parser-output .side-box-text{padding:0.25em 0.9em}.mw-parser-output .side-box-image{padding:2px 0 2px 0.9em;text-align:center}.mw-parser-output .side-box-imageright{padding:2px 0.9em 2px 0;text-align:center}@media(min-width:500px){.mw-parser-output .side-box-flex{display:flex;align-items:center}.mw-parser-output .side-box-text{flex:1;min-width:0}}@media(min-width:720px){.mw-parser-output .side-box{width:238px}.mw-parser-output .side-box-right{clear:right;float:right;margin-left:1em}.mw-parser-output .side-box-left{margin-right:1em}}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1237033735">

/* start https://en.wikipedia.org/ */

@media print{body.ns-0 .mw-parser-output .sistersitebox{display:none!important}}@media screen{html.skin-theme-clientpref-night .mw-parser-output .sistersitebox img[src*="Wiktionary-logo-en-v2.svg"]{background-color:white}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .sistersitebox img[src*="Wiktionary-logo-en-v2.svg"]{background-color:white}}

/* end https://en.wikipedia.org/ */

</style><div class="side-box side-box-right sistersitebox"><style data-mw-deduplicate="TemplateStyles:r1126788409">

/* start https://en.wikipedia.org/ */

.mw-parser-output .plainlist ol,.mw-parser-output .plainlist ul{line-height:inherit;list-style:none;margin:0;padding:0}.mw-parser-output .plainlist ol li,.mw-parser-output .plainlist ul li{margin-bottom:0}

/* end https://en.wikipedia.org/ */

</style>

<div class="side-box-text plainlist">Wikimedia Commons has media related to <a href="https://commons.wikimedia.org/wiki/Category:Logic_programming" class="extiw external" title="commons:Category:Logic programming">Logic programming</a>.</div></div>

</div>

<ul><li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20050828194751/http://vl.fmnet.info/logic-prog/">Logic Programming Virtual Library entry</a></li>

<li><a rel="nofollow" class="external text" href="http://liinwww.ira.uka.de/bibliography/LogicProgramming/">Bibliographies on Logic Programming</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081204113711/http://liinwww.ira.uka.de/bibliography/LogicProgramming/">Archived</a> 2008-12-04 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></li>

<li><a rel="nofollow" class="external text" href="http://www.logicprogramming.org/">Association for Logic Programming (ALP)</a></li>

<li><a rel="nofollow" class="external text" href="http://www.cs.kuleuven.be/~dtai/projects/ALP/TPLP/">Theory and Practice of Logic Programming</a> (journal)</li>

<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20090108012954/http://www.mpprogramming.com/Cpp/">Logic programming in C++ with Castor</a></li>

<li><a rel="nofollow" class="external text" href="http://www.mozart-oz.org/documentation/tutorial/node12.html">Logic programming</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20110903022204/http://www.mozart-oz.org/documentation/tutorial/node12.html">Archived</a> 2011-09-03 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> in <a href="Oz_programming_language" class="mw-redirect" title="Oz programming language">Oz</a></li>

<li><a rel="nofollow" class="external text" href="http://www.pdc.dk/">Prolog Development Center </a></li>

<li><a rel="nofollow" class="external text" href="http://docs.racket-lang.org/racklog/">Racklog: Logic Programming in Racket</a></li></ul>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Programming_paradigms_(Comparison_by_language)368" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Programming_paradigms_(Comparison_by_language)368" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Programming paradigms</a> (<a href="Comparison_of_multi-paradigm_programming_languages" title="Comparison of multi-paradigm programming languages">Comparison by language</a>)</div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Imperative_programming" title="Imperative programming">Imperative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Structured_programming" title="Structured programming">Structured</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Jackson_structured_programming" title="Jackson structured programming">Jackson structures</a></li>

<li><a href="Block_(programming)" title="Block (programming)">Block-structured</a></li>

<li><a href="Modular_programming" title="Modular programming">Modular</a></li>

<li><a href="Non-structured_programming" title="Non-structured programming">Non-structured</a></li>

<li><a href="Procedural_programming" title="Procedural programming">Procedural</a></li>

<li><a href="Programming_in_the_large_and_programming_in_the_small" title="Programming in the large and programming in the small">Programming in the large and in the small</a></li>

<li><a href="Design_by_contract" title="Design by contract">Design by contract</a></li>

<li><a href="Invariant-based_programming" title="Invariant-based programming">Invariant-based</a></li>

<li><a href="Nested_function" title="Nested function">Nested function</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Object-oriented_programming" title="Object-oriented programming">Object-oriented</a> (<a href="Comparison_of_programming_languages_(object-oriented_programming)" title="Comparison of programming languages (object-oriented programming)">comparison</a>, <a href="List_of_object-oriented_programming_languages" title="List of object-oriented programming languages">list</a>)</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Class-based_programming" title="Class-based programming">Class-based</a>, <a href="Prototype-based_programming" title="Prototype-based programming">Prototype-based</a>, <a href="Object-based_language" title="Object-based language">Object-based</a></li>

<li><a href="Agent-oriented_programming" title="Agent-oriented programming">Agent</a></li>

<li><a href="Immutable_object" title="Immutable object">Immutable object</a></li>

<li><a href="Persistent_programming_language" title="Persistent programming language">Persistent</a></li>

<li><a href="Uniform_function_call_syntax" title="Uniform function call syntax">Uniform function call syntax</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Declarative_programming" title="Declarative programming">Declarative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Functional_programming" title="Functional programming">Functional</a> (<a href="Comparison_of_functional_programming_languages" title="Comparison of functional programming languages">comparison</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Recursion_(computer_science)" title="Recursion (computer science)">Recursive</a></li>

<li><a href="Anonymous_function" title="Anonymous function">Anonymous function</a> (<a href="Partial_application" title="Partial application">Partial application</a>)</li>

<li><a href="Higher-order_programming" title="Higher-order programming">Higher-order</a></li>

<li><a href="Purely_functional_programming" title="Purely functional programming">Purely functional</a></li>

<li><a href="Total_functional_programming" title="Total functional programming">Total</a></li>

<li><a href="Strict_programming_language" title="Strict programming language">Strict</a></li>

<li><a href="Generalized_algebraic_data_type" title="Generalized algebraic data type">GADTs</a></li>

<li><a href="Dependent_type" title="Dependent type">Dependent types</a></li>

<li><a href="Functional_logic_programming" title="Functional logic programming">Functional logic</a></li>

<li><a href="Tacit_programming" title="Tacit programming">Point-free style</a></li>

<li><a href="Expression-oriented_programming_language" title="Expression-oriented programming language">Expression-oriented</a></li>

<li><a href="Applicative_programming_language" title="Applicative programming language">Applicative</a>, <a href="Concatenative_programming_language" title="Concatenative programming language">Concatenative</a></li>

<li><a href="Function-level_programming" title="Function-level programming">Function-level</a>, <a href="Value-level_programming" title="Value-level programming">Value-level</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Dataflow_programming" title="Dataflow programming">Dataflow</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Flow-based_programming" title="Flow-based programming">Flow-based</a></li>

<li><a href="Reactive_programming" title="Reactive programming">Reactive</a> (<a href="Functional_reactive_programming" title="Functional reactive programming">Functional reactive</a>)</li>

<li><a href="Signal_programming" class="mw-redirect" title="Signal programming">Signals</a></li>

<li><a href="Stream_processing" title="Stream processing">Streams</a></li>

<li><a href="Synchronous_programming_language" title="Synchronous programming language">Synchronous</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Abductive_logic_programming" title="Abductive logic programming">Abductive logic</a></li>

<li><a href="Answer_set_programming" title="Answer set programming">Answer set</a></li>

<li><a href="Constraint_programming" title="Constraint programming">Constraint</a> (<a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic</a>)</li>

<li><a href="Inductive_logic_programming" title="Inductive logic programming">Inductive logic</a></li>

<li><a href="Nondeterministic_programming" title="Nondeterministic programming">Nondeterministic</a></li>

<li><a href="Ontology_language" title="Ontology language">Ontology</a></li>

<li><a href="Probabilistic_logic_programming" title="Probabilistic logic programming">Probabilistic logic</a></li>

<li><a href="Query_language" title="Query language">Query</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Domain-specific_language" title="Domain-specific language">DSL</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Algebraic_modeling_language" title="Algebraic modeling language">Algebraic modeling</a></li>

<li><a href="Array_programming" title="Array programming">Array</a></li>

<li><a href="Automata-based_programming" title="Automata-based programming">Automata-based</a> (<a href="Action_language" title="Action language">Action</a>)</li>

<li><a href="Command_language" title="Command language">Command</a> (<a href="Spacecraft_command_language" title="Spacecraft command language">Spacecraft</a>)</li>

<li><a href="Differentiable_programming" title="Differentiable programming">Differentiable</a></li>

<li><a href="Grammar-oriented_programming" title="Grammar-oriented programming">Grammar-oriented</a></li>

<li><a href="Interface_description_language" title="Interface description language">Interface description</a></li>

<li><a href="Language-oriented_programming" title="Language-oriented programming">Language-oriented</a></li>

<li><a href="List_comprehension" title="List comprehension">List comprehension</a></li>

<li><a href="Modeling_language" title="Modeling language">Modeling</a></li>

<li><a href="Natural-language_programming" class="mw-redirect" title="Natural-language programming">Natural language</a></li>

<li><a href="Non-English-based_programming_languages" title="Non-English-based programming languages">Non-English-based</a></li>

<li><a href="Page_description_language" title="Page description language">Page description</a></li>

<li><a href="Pipeline_(software)" title="Pipeline (software)">Pipes</a> and <a href="Filter_(software)" title="Filter (software)">filters</a></li>

<li><a href="Probabilistic_programming" title="Probabilistic programming">Probabilistic</a></li>

<li><a href="Quantum_programming" title="Quantum programming">Quantum</a></li>

<li><a href="Scientific_programming_language" title="Scientific programming language">Scientific</a></li>

<li><a href="Scripting_language" title="Scripting language">Scripting</a></li>

<li><a href="Set_theoretic_programming" title="Set theoretic programming">Set-theoretic</a></li>

<li><a href="Simulation_language" title="Simulation language">Simulation</a></li>

<li><a href="Stack-oriented_programming" title="Stack-oriented programming">Stack-based</a></li>

<li><a href="System_programming_language" title="System programming language">System</a></li>

<li><a href="Tactile_programming_language" title="Tactile programming language">Tactile</a></li>

<li><a href="Template_processor" title="Template processor">Templating</a></li>

<li><a href="Transformation_language" title="Transformation language">Transformation</a> (<a href="Graph_rewriting" title="Graph rewriting">Graph rewriting</a>, <a href="Production_system_(computer_science)" title="Production system (computer science)">Production</a>, <a href="Pattern_matching" title="Pattern matching">Pattern</a>)</li>

<li><a href="Visual_programming_language" title="Visual programming language">Visual</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Concurrent_computing" title="Concurrent computing">Concurrent</a>, <a href="Distributed_computing" title="Distributed computing">distributed</a>, <a href="Parallel_computing" title="Parallel computing">parallel</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Actor_model" title="Actor model">Actor-based</a></li>

<li><a href="Automatic_mutual_exclusion" title="Automatic mutual exclusion">Automatic mutual exclusion</a></li>

<li><a href="Choreographic_programming" title="Choreographic programming">Choreographic programming</a></li>

<li><a href="Concurrent_logic_programming" title="Concurrent logic programming">Concurrent logic</a> (<a href="Concurrent_constraint_logic_programming" title="Concurrent constraint logic programming">Concurrent constraint logic</a>)</li>

<li><a href="Concurrent_object-oriented_programming" title="Concurrent object-oriented programming">Concurrent OO</a></li>

<li><a href="Macroprogramming" title="Macroprogramming">Macroprogramming</a></li>

<li><a href="Multitier_programming" title="Multitier programming">Multitier programming</a></li>

<li><a href="Organic_computing" title="Organic computing">Organic computing</a></li>

<li><a href="Parallel_programming_model" title="Parallel programming model">Parallel programming models</a></li>

<li><a href="Partitioned_global_address_space" title="Partitioned global address space">Partitioned global address space</a></li>

<li><a href="Process-oriented_programming" title="Process-oriented programming">Process-oriented</a></li>

<li><a href="Relativistic_programming" title="Relativistic programming">Relativistic programming</a></li>

<li><a href="Service-oriented_programming" title="Service-oriented programming">Service-oriented</a></li>

<li><a href="Structured_concurrency" title="Structured concurrency">Structured concurrency</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Metaprogramming" title="Metaprogramming">Metaprogramming</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Attribute-oriented_programming" title="Attribute-oriented programming">Attribute-oriented</a></li>

<li><a href="Automatic_programming" title="Automatic programming">Automatic</a> (<a href="Inductive_programming" title="Inductive programming">Inductive</a>)</li>

<li><a href="Dynamic_programming_language" title="Dynamic programming language">Dynamic</a></li>

<li><a href="Extensible_programming" title="Extensible programming">Extensible</a></li>

<li><a href="Generic_programming" title="Generic programming">Generic</a></li>

<li><a href="Homoiconicity" title="Homoiconicity">Homoiconicity</a></li>

<li><a href="Interactive_programming" title="Interactive programming">Interactive</a></li>

<li><a href="Macro_(computer_science)" title="Macro (computer science)">Macro</a> (<a href="Hygienic_macro" title="Hygienic macro">Hygienic</a>)</li>

<li><a href="Metalinguistic_abstraction" title="Metalinguistic abstraction">Metalinguistic abstraction</a></li>

<li><a href="Multi-stage_programming" title="Multi-stage programming">Multi-stage</a></li>

<li><a href="Program_synthesis" title="Program synthesis">Program synthesis</a> (<a href="Bayesian_program_synthesis" title="Bayesian program synthesis">Bayesian</a>, <a href="Inferential_programming" title="Inferential programming">Inferential</a>, <a href="Programming_by_demonstration" title="Programming by demonstration">by demonstration</a>, <a href="Programming_by_example" title="Programming by example">by example</a>)</li>

<li><a href="Reflective_programming" title="Reflective programming">Reflective</a></li>

<li><a href="Self-modifying_code" title="Self-modifying code">Self-modifying code</a></li>

<li><a href="Symbolic_programming" title="Symbolic programming">Symbolic</a></li>

<li><a href="Template_metaprogramming" title="Template metaprogramming">Template</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Separation_of_concerns" title="Separation of concerns">Separation of concerns</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Aspect-oriented_programming" title="Aspect-oriented programming">Aspects</a></li>

<li><a href="Component-based_software_engineering" title="Component-based software engineering">Components</a></li>

<li><a href="Data-driven_programming" title="Data-driven programming">Data-driven</a></li>

<li><a href="Data-oriented_design" title="Data-oriented design">Data-oriented</a></li>

<li><a href="Event-driven_programming" title="Event-driven programming">Event-driven</a></li>

<li><a href="Feature-oriented_programming" title="Feature-oriented programming">Features</a></li>

<li><a href="Literate_programming" title="Literate programming">Literate</a></li>

<li><a href="Role-oriented_programming" title="Role-oriented programming">Roles</a></li>

<li><a href="Subject-oriented_programming" title="Subject-oriented programming">Subjects</a></li></ul>

</div></td></tr></tbody></table></div>

<div class="navbox-styles"></div><div role="navigation" class="navbox" aria-labelledby="Types_of_programming_languages107" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Types_of_programming_languages107" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Types of programming languages</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">Level</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Machine_code" title="Machine code">Machine</a></li>

<li><a href="Assembly_language" title="Assembly language">Assembly</a></li>

<li><a href="Compiled_language" title="Compiled language">Compiled</a></li>

<li><a href="Interpreted_language" class="mw-redirect" title="Interpreted language">Interpreted</a></li></ul>

<ul><li><a href="Low-level_programming_language" title="Low-level programming language">Low-level</a></li>

<li><a href="High-level_programming_language" title="High-level programming language">High-level</a></li>

<li><a href="Very_high-level_programming_language" title="Very high-level programming language">Very high-level</a></li>

<li><a href="Esoteric_programming_language" title="Esoteric programming language">Esoteric</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Programming_language_generations" title="Programming language generations">Generation</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="First-generation_programming_language" title="First-generation programming language">First</a></li>

<li><a href="Second-generation_programming_language" title="Second-generation programming language">Second</a></li>

<li><a href="Third-generation_programming_language" title="Third-generation programming language">Third</a></li>

<li><a href="Fourth-generation_programming_language" title="Fourth-generation programming language">Fourth</a></li>

<li><a href="Fifth-generation_programming_language" title="Fifth-generation programming language">Fifth</a></li></ul>

</div></td></tr></tbody></table></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .tooltip-dotted{border-bottom:1px dotted;cursor:help}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox authority-control" aria-labelledby="Authority_control_databases_frameless&#124;text-top&#124;10px&#124;alt=Edit_this_at_Wikidata&#124;link=https&#58;//www.wikidata.org/wiki/Q275603#identifiers&#124;class=noprint&#124;Edit_this_at_Wikidata1260" style="padding:3px"><table class="nowraplinks hlist mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Authority_control_databases_frameless&#124;text-top&#124;10px&#124;alt=Edit_this_at_Wikidata&#124;link=https&#58;//www.wikidata.org/wiki/Q275603#identifiers&#124;class=noprint&#124;Edit_this_at_Wikidata1260" style="font-size:114%;margin:0 4em">Authority control databases </div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">National</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"><ul><li><a rel="nofollow" class="external text" href="https://d-nb.info/gnd/4195096-3">Germany</a></li><li><a rel="nofollow" class="external text" href="https://id.loc.gov/authorities/sh86003454">United States</a></li><li><a rel="nofollow" class="external text" href="https://catalogue.bnf.fr/ark:/12148/cb12067891q">France</a></li><li><a rel="nofollow" class="external text" href="https://data.bnf.fr/ark:/12148/cb12067891q">BnF data</a></li><li><a rel="nofollow" class="external text" href="https://aleph.nkp.cz/F/?func=find-c&local_base=aut&ccl_term=ica=ph122430&CON_LNG=ENG">Czech Republic</a></li><li><a rel="nofollow" class="external text" href="https://datos.bne.es/resource/XX550687">Spain</a></li><li><a rel="nofollow" class="external text" href="https://www.nli.org.il/en/authorities/987007553495005171">Israel</a></li></ul></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Other</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em"><ul><li><a rel="nofollow" class="external text" href="https://lux.collections.yale.edu/view/concept/14a984a2-3609-4533-a755-951f0c1c8b84">Yale LUX</a></li></ul></div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-07-12" href="https://en.wikipedia.org/wiki/?title=Logic_programming&oldid=1300095526">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>